LTKCPP-- LLRP Toolkit C Plus Plus Library
x86/src/generated/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 {
229 
230  AirProtocols_Unspecified = 0,
231  AirProtocols_EPCGlobalClass1Gen2 = 1,
232 };
233 
234 extern const SEnumTableEntry
235 g_estAirProtocols[];
236 
237 
261 enum EGetReaderCapabilitiesRequestedData
262 {
263 
264  GetReaderCapabilitiesRequestedData_All = 0,
265  GetReaderCapabilitiesRequestedData_General_Device_Capabilities = 1,
266  GetReaderCapabilitiesRequestedData_LLRP_Capabilities = 2,
267  GetReaderCapabilitiesRequestedData_Regulatory_Capabilities = 3,
268  GetReaderCapabilitiesRequestedData_LLRP_Air_Protocol_Capabilities = 4,
269 };
270 
271 extern const SEnumTableEntry
272 g_estGetReaderCapabilitiesRequestedData[];
273 
274 
310 enum ECommunicationsStandard
311 {
312 
313  CommunicationsStandard_Unspecified = 0,
314  CommunicationsStandard_US_FCC_Part_15 = 1,
315  CommunicationsStandard_ETSI_302_208 = 2,
316  CommunicationsStandard_ETSI_300_220 = 3,
317  CommunicationsStandard_Australia_LIPD_1W = 4,
318  CommunicationsStandard_Australia_LIPD_4W = 5,
319  CommunicationsStandard_Japan_ARIB_STD_T89 = 6,
320  CommunicationsStandard_Hong_Kong_OFTA_1049 = 7,
321  CommunicationsStandard_Taiwan_DGT_LP0002 = 8,
322  CommunicationsStandard_Korea_MIC_Article_5_2 = 9,
323 };
324 
325 extern const SEnumTableEntry
326 g_estCommunicationsStandard[];
327 
328 
350 enum EROSpecState
351 {
352 
353  ROSpecState_Disabled = 0,
354  ROSpecState_Inactive = 1,
355  ROSpecState_Active = 2,
356 };
357 
358 extern const SEnumTableEntry
359 g_estROSpecState[];
360 
361 
415 enum EROSpecStartTriggerType
416 {
417 
418  ROSpecStartTriggerType_Null = 0,
419  ROSpecStartTriggerType_Immediate = 1,
420  ROSpecStartTriggerType_Periodic = 2,
421  ROSpecStartTriggerType_GPI = 3,
422 };
423 
424 extern const SEnumTableEntry
425 g_estROSpecStartTriggerType[];
426 
427 
475 enum EROSpecStopTriggerType
476 {
477 
478  ROSpecStopTriggerType_Null = 0,
479  ROSpecStopTriggerType_Duration = 1,
480  ROSpecStopTriggerType_GPI_With_Timeout = 2,
481 };
482 
483 extern const SEnumTableEntry
484 g_estROSpecStopTriggerType[];
485 
486 
540 enum EAISpecStopTriggerType
541 {
542 
543  AISpecStopTriggerType_Null = 0,
544  AISpecStopTriggerType_Duration = 1,
545  AISpecStopTriggerType_GPI_With_Timeout = 2,
546  AISpecStopTriggerType_Tag_Observation = 3,
547 };
548 
549 extern const SEnumTableEntry
550 g_estAISpecStopTriggerType[];
551 
552 
600 enum ETagObservationTriggerType
601 {
602 
603  TagObservationTriggerType_Upon_Seeing_N_Tags_Or_Timeout = 0,
604  TagObservationTriggerType_Upon_Seeing_No_More_New_Tags_For_Tms_Or_Timeout = 1,
605  TagObservationTriggerType_N_Attempts_To_See_All_Tags_In_FOV_Or_Timeout = 2,
606 };
607 
608 extern const SEnumTableEntry
609 g_estTagObservationTriggerType[];
610 
611 
633 enum ERFSurveySpecStopTriggerType
634 {
635 
636  RFSurveySpecStopTriggerType_Null = 0,
637  RFSurveySpecStopTriggerType_Duration = 1,
638  RFSurveySpecStopTriggerType_N_Iterations_Through_Frequency_Range = 2,
639 };
640 
641 extern const SEnumTableEntry
642 g_estRFSurveySpecStopTriggerType[];
643 
644 
665 enum EAccessSpecState
666 {
667 
668  AccessSpecState_Disabled = 0,
669  AccessSpecState_Active = 1,
670 };
671 
672 extern const SEnumTableEntry
673 g_estAccessSpecState[];
674 
675 
717 enum EAccessSpecStopTriggerType
718 {
719 
720  AccessSpecStopTriggerType_Null = 0,
721  AccessSpecStopTriggerType_Operation_Count = 1,
722 };
723 
724 extern const SEnumTableEntry
725 g_estAccessSpecStopTriggerType[];
726 
727 
758 enum EGetReaderConfigRequestedData
759 {
760 
761  GetReaderConfigRequestedData_All = 0,
762  GetReaderConfigRequestedData_Identification = 1,
763  GetReaderConfigRequestedData_AntennaProperties = 2,
764  GetReaderConfigRequestedData_AntennaConfiguration = 3,
765  GetReaderConfigRequestedData_ROReportSpec = 4,
766  GetReaderConfigRequestedData_ReaderEventNotificationSpec = 5,
767  GetReaderConfigRequestedData_AccessReportSpec = 6,
768  GetReaderConfigRequestedData_LLRPConfigurationStateValue = 7,
769  GetReaderConfigRequestedData_KeepaliveSpec = 8,
770  GetReaderConfigRequestedData_GPIPortCurrentState = 9,
771  GetReaderConfigRequestedData_GPOWriteData = 10,
772  GetReaderConfigRequestedData_EventsAndReports = 11,
773 };
774 
775 extern const SEnumTableEntry
776 g_estGetReaderConfigRequestedData[];
777 
778 
799 enum EIdentificationType
800 {
801 
802  IdentificationType_MAC_Address = 0,
803  IdentificationType_EPC = 1,
804 };
805 
806 extern const SEnumTableEntry
807 g_estIdentificationType[];
808 
809 
853 enum EKeepaliveTriggerType
854 {
855 
856  KeepaliveTriggerType_Null = 0,
857  KeepaliveTriggerType_Periodic = 1,
858 };
859 
860 extern const SEnumTableEntry
861 g_estKeepaliveTriggerType[];
862 
863 
885 enum EGPIPortState
886 {
887 
888  GPIPortState_Low = 0,
889  GPIPortState_High = 1,
890  GPIPortState_Unknown = 2,
891 };
892 
893 extern const SEnumTableEntry
894 g_estGPIPortState[];
895 
896 
918 enum EROReportTriggerType
919 {
920 
921  ROReportTriggerType_None = 0,
922  ROReportTriggerType_Upon_N_Tags_Or_End_Of_AISpec = 1,
923  ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec = 2,
924 };
925 
926 extern const SEnumTableEntry
927 g_estROReportTriggerType[];
928 
929 
950 enum EAccessReportTriggerType
951 {
952 
953  AccessReportTriggerType_Whenever_ROReport_Is_Generated = 0,
954  AccessReportTriggerType_End_Of_AccessSpec = 1,
955 };
956 
957 extern const SEnumTableEntry
958 g_estAccessReportTriggerType[];
959 
960 
988 enum ENotificationEventType
989 {
990 
991  NotificationEventType_Upon_Hopping_To_Next_Channel = 0,
992  NotificationEventType_GPI_Event = 1,
993  NotificationEventType_ROSpec_Event = 2,
994  NotificationEventType_Report_Buffer_Fill_Warning = 3,
995  NotificationEventType_Reader_Exception_Event = 4,
996  NotificationEventType_RFSurvey_Event = 5,
997  NotificationEventType_AISpec_Event = 6,
998  NotificationEventType_AISpec_Event_With_Details = 7,
999  NotificationEventType_Antenna_Event = 8,
1000 };
1001 
1002 extern const SEnumTableEntry
1003 g_estNotificationEventType[];
1004 
1005 
1027 enum EROSpecEventType
1028 {
1029 
1030  ROSpecEventType_Start_Of_ROSpec = 0,
1031  ROSpecEventType_End_Of_ROSpec = 1,
1032  ROSpecEventType_Preemption_Of_ROSpec = 2,
1033 };
1034 
1035 extern const SEnumTableEntry
1036 g_estROSpecEventType[];
1037 
1038 
1059 enum ERFSurveyEventType
1060 {
1061 
1062  RFSurveyEventType_Start_Of_RFSurvey = 0,
1063  RFSurveyEventType_End_Of_RFSurvey = 1,
1064 };
1065 
1066 extern const SEnumTableEntry
1067 g_estRFSurveyEventType[];
1068 
1069 
1089 enum EAISpecEventType
1090 {
1091 
1092  AISpecEventType_End_Of_AISpec = 0,
1093 };
1094 
1095 extern const SEnumTableEntry
1096 g_estAISpecEventType[];
1097 
1098 
1120 enum EAntennaEventType
1121 {
1122 
1123  AntennaEventType_Antenna_Disconnected = 0,
1124  AntennaEventType_Antenna_Connected = 1,
1125 };
1126 
1127 extern const SEnumTableEntry
1128 g_estAntennaEventType[];
1129 
1130 
1158 enum EConnectionAttemptStatusType
1159 {
1160 
1161  ConnectionAttemptStatusType_Success = 0,
1162  ConnectionAttemptStatusType_Failed_A_Reader_Initiated_Connection_Already_Exists = 1,
1163  ConnectionAttemptStatusType_Failed_A_Client_Initiated_Connection_Already_Exists = 2,
1164  ConnectionAttemptStatusType_Failed_Reason_Other_Than_A_Connection_Already_Exists = 3,
1165  ConnectionAttemptStatusType_Another_Connection_Attempted = 4,
1166 };
1167 
1168 extern const SEnumTableEntry
1169 g_estConnectionAttemptStatusType[];
1170 
1171 
1223 enum EStatusCode
1224 {
1225 
1226  StatusCode_M_Success = 0,
1227  StatusCode_M_ParameterError = 100,
1228  StatusCode_M_FieldError = 101,
1229  StatusCode_M_UnexpectedParameter = 102,
1230  StatusCode_M_MissingParameter = 103,
1231  StatusCode_M_DuplicateParameter = 104,
1232  StatusCode_M_OverflowParameter = 105,
1233  StatusCode_M_OverflowField = 106,
1234  StatusCode_M_UnknownParameter = 107,
1235  StatusCode_M_UnknownField = 108,
1236  StatusCode_M_UnsupportedMessage = 109,
1237  StatusCode_M_UnsupportedVersion = 110,
1238  StatusCode_M_UnsupportedParameter = 111,
1239  StatusCode_P_ParameterError = 200,
1240  StatusCode_P_FieldError = 201,
1241  StatusCode_P_UnexpectedParameter = 202,
1242  StatusCode_P_MissingParameter = 203,
1243  StatusCode_P_DuplicateParameter = 204,
1244  StatusCode_P_OverflowParameter = 205,
1245  StatusCode_P_OverflowField = 206,
1246  StatusCode_P_UnknownParameter = 207,
1247  StatusCode_P_UnknownField = 208,
1248  StatusCode_P_UnsupportedParameter = 209,
1249  StatusCode_A_Invalid = 300,
1250  StatusCode_A_OutOfRange = 301,
1251  StatusCode_R_DeviceError = 401,
1252 };
1253 
1254 extern const SEnumTableEntry
1255 g_estStatusCode[];
1256 
1257 
1278 enum EC1G2DRValue
1279 {
1280 
1281  C1G2DRValue_DRV_8 = 0,
1282  C1G2DRValue_DRV_64_3 = 1,
1283 };
1284 
1285 extern const SEnumTableEntry
1286 g_estC1G2DRValue[];
1287 
1288 
1311 enum EC1G2MValue
1312 {
1313 
1314  C1G2MValue_MV_FM0 = 0,
1315  C1G2MValue_MV_2 = 1,
1316  C1G2MValue_MV_4 = 2,
1317  C1G2MValue_MV_8 = 3,
1318 };
1319 
1320 extern const SEnumTableEntry
1321 g_estC1G2MValue[];
1322 
1323 
1345 enum EC1G2ForwardLinkModulation
1346 {
1347 
1348  C1G2ForwardLinkModulation_PR_ASK = 0,
1349  C1G2ForwardLinkModulation_SSB_ASK = 1,
1350  C1G2ForwardLinkModulation_DSB_ASK = 2,
1351 };
1352 
1353 extern const SEnumTableEntry
1354 g_estC1G2ForwardLinkModulation[];
1355 
1356 
1410 enum EC1G2SpectralMaskIndicator
1411 {
1412 
1413  C1G2SpectralMaskIndicator_Unknown = 0,
1414  C1G2SpectralMaskIndicator_SI = 1,
1415  C1G2SpectralMaskIndicator_MI = 2,
1416  C1G2SpectralMaskIndicator_DI = 3,
1417 };
1418 
1419 extern const SEnumTableEntry
1420 g_estC1G2SpectralMaskIndicator[];
1421 
1422 
1444 enum EC1G2TruncateAction
1445 {
1446 
1447  C1G2TruncateAction_Unspecified = 0,
1448  C1G2TruncateAction_Do_Not_Truncate = 1,
1449  C1G2TruncateAction_Truncate = 2,
1450 };
1451 
1452 extern const SEnumTableEntry
1453 g_estC1G2TruncateAction[];
1454 
1455 
1479 enum EC1G2StateAwareTarget
1480 {
1481 
1482  C1G2StateAwareTarget_SL = 0,
1483  C1G2StateAwareTarget_Inventoried_State_For_Session_S0 = 1,
1484  C1G2StateAwareTarget_Inventoried_State_For_Session_S1 = 2,
1485  C1G2StateAwareTarget_Inventoried_State_For_Session_S2 = 3,
1486  C1G2StateAwareTarget_Inventoried_State_For_Session_S3 = 4,
1487 };
1488 
1489 extern const SEnumTableEntry
1490 g_estC1G2StateAwareTarget[];
1491 
1492 
1519 enum EC1G2StateAwareAction
1520 {
1521 
1522  C1G2StateAwareAction_AssertSLOrA_DeassertSLOrB = 0,
1523  C1G2StateAwareAction_AssertSLOrA_Noop = 1,
1524  C1G2StateAwareAction_Noop_DeassertSLOrB = 2,
1525  C1G2StateAwareAction_NegateSLOrABBA_Noop = 3,
1526  C1G2StateAwareAction_DeassertSLOrB_AssertSLOrA = 4,
1527  C1G2StateAwareAction_DeassertSLOrB_Noop = 5,
1528  C1G2StateAwareAction_Noop_AssertSLOrA = 6,
1529  C1G2StateAwareAction_Noop_NegateSLOrABBA = 7,
1530 };
1531 
1532 extern const SEnumTableEntry
1533 g_estC1G2StateAwareAction[];
1534 
1535 
1560 enum EC1G2StateUnawareAction
1561 {
1562 
1563  C1G2StateUnawareAction_Select_Unselect = 0,
1564  C1G2StateUnawareAction_Select_DoNothing = 1,
1565  C1G2StateUnawareAction_DoNothing_Unselect = 2,
1566  C1G2StateUnawareAction_Unselect_DoNothing = 3,
1567  C1G2StateUnawareAction_Unselect_Select = 4,
1568  C1G2StateUnawareAction_DoNothing_Select = 5,
1569 };
1570 
1571 extern const SEnumTableEntry
1572 g_estC1G2StateUnawareAction[];
1573 
1574 
1595 enum EC1G2TagInventoryStateAwareI
1596 {
1597 
1598  C1G2TagInventoryStateAwareI_State_A = 0,
1599  C1G2TagInventoryStateAwareI_State_B = 1,
1600 };
1601 
1602 extern const SEnumTableEntry
1603 g_estC1G2TagInventoryStateAwareI[];
1604 
1605 
1626 enum EC1G2TagInventoryStateAwareS
1627 {
1628 
1629  C1G2TagInventoryStateAwareS_SL = 0,
1630  C1G2TagInventoryStateAwareS_Not_SL = 1,
1631 };
1632 
1633 extern const SEnumTableEntry
1634 g_estC1G2TagInventoryStateAwareS[];
1635 
1636 
1666 enum EC1G2LockPrivilege
1667 {
1668 
1669  C1G2LockPrivilege_Read_Write = 0,
1670  C1G2LockPrivilege_Perma_Lock = 1,
1671  C1G2LockPrivilege_Perma_Unlock = 2,
1672  C1G2LockPrivilege_Unlock = 3,
1673 };
1674 
1675 extern const SEnumTableEntry
1676 g_estC1G2LockPrivilege[];
1677 
1678 
1702 enum EC1G2LockDataField
1703 {
1704 
1705  C1G2LockDataField_Kill_Password = 0,
1706  C1G2LockDataField_Access_Password = 1,
1707  C1G2LockDataField_EPC_Memory = 2,
1708  C1G2LockDataField_TID_Memory = 3,
1709  C1G2LockDataField_User_Memory = 4,
1710 };
1711 
1712 extern const SEnumTableEntry
1713 g_estC1G2LockDataField[];
1714 
1715 
1738 enum EC1G2ReadResultType
1739 {
1740 
1741  C1G2ReadResultType_Success = 0,
1742  C1G2ReadResultType_Nonspecific_Tag_Error = 1,
1743  C1G2ReadResultType_No_Response_From_Tag = 2,
1744  C1G2ReadResultType_Nonspecific_Reader_Error = 3,
1745 };
1746 
1747 extern const SEnumTableEntry
1748 g_estC1G2ReadResultType[];
1749 
1750 
1780 enum EC1G2WriteResultType
1781 {
1782 
1783  C1G2WriteResultType_Success = 0,
1784  C1G2WriteResultType_Tag_Memory_Overrun_Error = 1,
1785  C1G2WriteResultType_Tag_Memory_Locked_Error = 2,
1786  C1G2WriteResultType_Insufficient_Power = 3,
1787  C1G2WriteResultType_Nonspecific_Tag_Error = 4,
1788  C1G2WriteResultType_No_Response_From_Tag = 5,
1789  C1G2WriteResultType_Nonspecific_Reader_Error = 6,
1790 };
1791 
1792 extern const SEnumTableEntry
1793 g_estC1G2WriteResultType[];
1794 
1795 
1820 enum EC1G2KillResultType
1821 {
1822 
1823  C1G2KillResultType_Success = 0,
1824  C1G2KillResultType_Zero_Kill_Password_Error = 1,
1825  C1G2KillResultType_Insufficient_Power = 2,
1826  C1G2KillResultType_Nonspecific_Tag_Error = 3,
1827  C1G2KillResultType_No_Response_From_Tag = 4,
1828  C1G2KillResultType_Nonspecific_Reader_Error = 5,
1829 };
1830 
1831 extern const SEnumTableEntry
1832 g_estC1G2KillResultType[];
1833 
1834 
1858 enum EC1G2LockResultType
1859 {
1860 
1861  C1G2LockResultType_Success = 0,
1862  C1G2LockResultType_Insufficient_Power = 1,
1863  C1G2LockResultType_Nonspecific_Tag_Error = 2,
1864  C1G2LockResultType_No_Response_From_Tag = 3,
1865  C1G2LockResultType_Nonspecific_Reader_Error = 4,
1866 };
1867 
1868 extern const SEnumTableEntry
1869 g_estC1G2LockResultType[];
1870 
1871 
1897 enum EC1G2BlockEraseResultType
1898 {
1899 
1900  C1G2BlockEraseResultType_Success = 0,
1901  C1G2BlockEraseResultType_Tag_Memory_Overrun_Error = 1,
1902  C1G2BlockEraseResultType_Tag_Memory_Locked_Error = 2,
1903  C1G2BlockEraseResultType_Insufficient_Power = 3,
1904  C1G2BlockEraseResultType_Nonspecific_Tag_Error = 4,
1905  C1G2BlockEraseResultType_No_Response_From_Tag = 5,
1906  C1G2BlockEraseResultType_Nonspecific_Reader_Error = 6,
1907 };
1908 
1909 extern const SEnumTableEntry
1910 g_estC1G2BlockEraseResultType[];
1911 
1912 
1942 enum EC1G2BlockWriteResultType
1943 {
1944 
1945  C1G2BlockWriteResultType_Success = 0,
1946  C1G2BlockWriteResultType_Tag_Memory_Overrun_Error = 1,
1947  C1G2BlockWriteResultType_Tag_Memory_Locked_Error = 2,
1948  C1G2BlockWriteResultType_Insufficient_Power = 3,
1949  C1G2BlockWriteResultType_Nonspecific_Tag_Error = 4,
1950  C1G2BlockWriteResultType_No_Response_From_Tag = 5,
1951  C1G2BlockWriteResultType_Nonspecific_Reader_Error = 6,
1952 };
1953 
1954 extern const SEnumTableEntry
1955 g_estC1G2BlockWriteResultType[];
1956 
1957 
1963 
2003 class CCUSTOM_MESSAGE : public CMessage
2004 {
2005  public:
2006  CCUSTOM_MESSAGE (void);
2007  ~CCUSTOM_MESSAGE (void);
2008 
2011 
2012  static const CFieldDescriptor * const
2013  s_apFieldDescriptorTable[];
2014 
2015  static const CTypeDescriptor
2016  s_typeDescriptor;
2017 
2018  void
2019  decodeFields (
2020  CDecoderStream * pDecoderStream);
2021 
2022  void
2023  assimilateSubParameters (
2024  CErrorDetails * pError);
2025 
2026  void
2027  encode (
2028  CEncoderStream * pEncoderStream) const;
2029 
2030 
2031 
2032  static CElement *
2033  s_construct (void);
2034 
2035  static void
2036  s_decodeFields (
2037  CDecoderStream * pDecoderStream,
2038  CElement * pElement);
2040 
2041 
2042  protected:
2043  llrp_u32_t m_VendorIdentifier;
2044 
2047  public:
2048  static const CFieldDescriptor
2049  s_fdVendorIdentifier;
2051 
2053  inline llrp_u32_t
2055  {
2056  return m_VendorIdentifier;
2057  }
2058 
2060  inline void
2062  llrp_u32_t value)
2063  {
2064  m_VendorIdentifier = value;
2065  }
2066 
2067 
2068  protected:
2069  llrp_u8_t m_MessageSubtype;
2070 
2073  public:
2074  static const CFieldDescriptor
2075  s_fdMessageSubtype;
2077 
2079  inline llrp_u8_t
2081  {
2082  return m_MessageSubtype;
2083  }
2084 
2086  inline void
2088  llrp_u8_t value)
2089  {
2090  m_MessageSubtype = value;
2091  }
2092 
2093 
2094  protected:
2095  llrp_bytesToEnd_t m_Data;
2096 
2099  public:
2100  static const CFieldDescriptor
2101  s_fdData;
2103 
2105  inline llrp_bytesToEnd_t
2106  getData (void)
2107  {
2108  return m_Data;
2109  }
2110 
2112  inline void
2114  llrp_bytesToEnd_t value)
2115  {
2116  m_Data = value;
2117  }
2118 
2119 
2120 
2121 };
2122 
2123 
2155 class CGET_READER_CAPABILITIES : public CMessage
2156 {
2157  public:
2158  CGET_READER_CAPABILITIES (void);
2159  ~CGET_READER_CAPABILITIES (void);
2160 
2163 
2164  static const CFieldDescriptor * const
2165  s_apFieldDescriptorTable[];
2166 
2167  static const CTypeDescriptor
2168  s_typeDescriptor;
2169 
2170  void
2171  decodeFields (
2172  CDecoderStream * pDecoderStream);
2173 
2174  void
2175  assimilateSubParameters (
2176  CErrorDetails * pError);
2177 
2178  void
2179  encode (
2180  CEncoderStream * pEncoderStream) const;
2181 
2182 
2183 
2184  static CElement *
2185  s_construct (void);
2186 
2187  static void
2188  s_decodeFields (
2189  CDecoderStream * pDecoderStream,
2190  CElement * pElement);
2192 
2193 
2194  protected:
2195  EGetReaderCapabilitiesRequestedData m_eRequestedData;
2196 
2199  public:
2200  static const CFieldDescriptor
2201  s_fdRequestedData;
2203 
2205  inline EGetReaderCapabilitiesRequestedData
2207  {
2208  return m_eRequestedData;
2209  }
2210 
2212  inline void
2214  EGetReaderCapabilitiesRequestedData value)
2215  {
2216  m_eRequestedData = value;
2217  }
2218 
2219 
2220 
2221  protected:
2222  std::list<CParameter *> m_listCustom;
2223 
2224  public:
2226  inline std::list<CParameter *>::iterator
2228  {
2229  return m_listCustom.begin();
2230  }
2231 
2233  inline std::list<CParameter *>::iterator
2234  endCustom (void)
2235  {
2236  return m_listCustom.end();
2237  }
2238 
2240  inline void
2242  {
2243  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2244  }
2245 
2247  inline int
2249  {
2250  return (int) (m_listCustom.size());
2251  }
2252 
2253  EResultCode
2255  addCustom (
2256  CParameter * pValue);
2257 
2258 
2259 };
2260 
2261 
2297 class CGET_READER_CAPABILITIES_RESPONSE : public CMessage
2298 {
2299  public:
2302 
2305 
2306  static const CFieldDescriptor * const
2307  s_apFieldDescriptorTable[];
2308 
2309  static const CTypeDescriptor
2310  s_typeDescriptor;
2311 
2312  void
2313  decodeFields (
2314  CDecoderStream * pDecoderStream);
2315 
2316  void
2317  assimilateSubParameters (
2318  CErrorDetails * pError);
2319 
2320  void
2321  encode (
2322  CEncoderStream * pEncoderStream) const;
2323 
2324 
2325 
2326  static CElement *
2327  s_construct (void);
2328 
2329  static void
2330  s_decodeFields (
2331  CDecoderStream * pDecoderStream,
2332  CElement * pElement);
2334 
2335 
2336 
2337  protected:
2338  CLLRPStatus * m_pLLRPStatus;
2339 
2340  public:
2342  inline CLLRPStatus *
2344  {
2345  return m_pLLRPStatus;
2346  }
2347 
2349  EResultCode
2350  setLLRPStatus (
2351  CLLRPStatus * pValue);
2352 
2353 
2354  protected:
2355  CGeneralDeviceCapabilities * m_pGeneralDeviceCapabilities;
2356 
2357  public:
2361  {
2362  return m_pGeneralDeviceCapabilities;
2363  }
2364 
2366  EResultCode
2367  setGeneralDeviceCapabilities (
2368  CGeneralDeviceCapabilities * pValue);
2369 
2370 
2371  protected:
2372  CLLRPCapabilities * m_pLLRPCapabilities;
2373 
2374  public:
2376  inline CLLRPCapabilities *
2378  {
2379  return m_pLLRPCapabilities;
2380  }
2381 
2383  EResultCode
2384  setLLRPCapabilities (
2385  CLLRPCapabilities * pValue);
2386 
2387 
2388  protected:
2389  CRegulatoryCapabilities * m_pRegulatoryCapabilities;
2390 
2391  public:
2393  inline CRegulatoryCapabilities *
2395  {
2396  return m_pRegulatoryCapabilities;
2397  }
2398 
2400  EResultCode
2401  setRegulatoryCapabilities (
2402  CRegulatoryCapabilities * pValue);
2403 
2404 
2405  protected:
2406  CParameter * m_pAirProtocolLLRPCapabilities;
2407 
2408  public:
2410  inline CParameter *
2412  {
2413  return m_pAirProtocolLLRPCapabilities;
2414  }
2415 
2417  EResultCode
2418  setAirProtocolLLRPCapabilities (
2419  CParameter * pValue);
2420 
2421 
2422  protected:
2423  std::list<CParameter *> m_listCustom;
2424 
2425  public:
2427  inline std::list<CParameter *>::iterator
2429  {
2430  return m_listCustom.begin();
2431  }
2432 
2434  inline std::list<CParameter *>::iterator
2435  endCustom (void)
2436  {
2437  return m_listCustom.end();
2438  }
2439 
2441  inline void
2443  {
2444  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2445  }
2446 
2448  inline int
2450  {
2451  return (int) (m_listCustom.size());
2452  }
2453 
2454  EResultCode
2456  addCustom (
2457  CParameter * pValue);
2458 
2459 
2460 };
2461 
2462 
2502 class CADD_ROSPEC : public CMessage
2503 {
2504  public:
2505  CADD_ROSPEC (void);
2506  ~CADD_ROSPEC (void);
2507 
2510 
2511  static const CFieldDescriptor * const
2512  s_apFieldDescriptorTable[];
2513 
2514  static const CTypeDescriptor
2515  s_typeDescriptor;
2516 
2517  void
2518  decodeFields (
2519  CDecoderStream * pDecoderStream);
2520 
2521  void
2522  assimilateSubParameters (
2523  CErrorDetails * pError);
2524 
2525  void
2526  encode (
2527  CEncoderStream * pEncoderStream) const;
2528 
2529 
2530 
2531  static CElement *
2532  s_construct (void);
2533 
2534  static void
2535  s_decodeFields (
2536  CDecoderStream * pDecoderStream,
2537  CElement * pElement);
2539 
2540 
2541 
2542  protected:
2543  CROSpec * m_pROSpec;
2544 
2545  public:
2547  inline CROSpec *
2548  getROSpec (void)
2549  {
2550  return m_pROSpec;
2551  }
2552 
2554  EResultCode
2555  setROSpec (
2556  CROSpec * pValue);
2557 
2558 
2559 };
2560 
2561 
2592 class CADD_ROSPEC_RESPONSE : public CMessage
2593 {
2594  public:
2595  CADD_ROSPEC_RESPONSE (void);
2596  ~CADD_ROSPEC_RESPONSE (void);
2597 
2600 
2601  static const CFieldDescriptor * const
2602  s_apFieldDescriptorTable[];
2603 
2604  static const CTypeDescriptor
2605  s_typeDescriptor;
2606 
2607  void
2608  decodeFields (
2609  CDecoderStream * pDecoderStream);
2610 
2611  void
2612  assimilateSubParameters (
2613  CErrorDetails * pError);
2614 
2615  void
2616  encode (
2617  CEncoderStream * pEncoderStream) const;
2618 
2619 
2620 
2621  static CElement *
2622  s_construct (void);
2623 
2624  static void
2625  s_decodeFields (
2626  CDecoderStream * pDecoderStream,
2627  CElement * pElement);
2629 
2630 
2631 
2632  protected:
2633  CLLRPStatus * m_pLLRPStatus;
2634 
2635  public:
2637  inline CLLRPStatus *
2639  {
2640  return m_pLLRPStatus;
2641  }
2642 
2644  EResultCode
2645  setLLRPStatus (
2646  CLLRPStatus * pValue);
2647 
2648 
2649 };
2650 
2651 
2685 class CDELETE_ROSPEC : public CMessage
2686 {
2687  public:
2688  CDELETE_ROSPEC (void);
2689  ~CDELETE_ROSPEC (void);
2690 
2693 
2694  static const CFieldDescriptor * const
2695  s_apFieldDescriptorTable[];
2696 
2697  static const CTypeDescriptor
2698  s_typeDescriptor;
2699 
2700  void
2701  decodeFields (
2702  CDecoderStream * pDecoderStream);
2703 
2704  void
2705  assimilateSubParameters (
2706  CErrorDetails * pError);
2707 
2708  void
2709  encode (
2710  CEncoderStream * pEncoderStream) const;
2711 
2712 
2713 
2714  static CElement *
2715  s_construct (void);
2716 
2717  static void
2718  s_decodeFields (
2719  CDecoderStream * pDecoderStream,
2720  CElement * pElement);
2722 
2723 
2724  protected:
2725  llrp_u32_t m_ROSpecID;
2726 
2729  public:
2730  static const CFieldDescriptor
2731  s_fdROSpecID;
2733 
2735  inline llrp_u32_t
2737  {
2738  return m_ROSpecID;
2739  }
2740 
2742  inline void
2744  llrp_u32_t value)
2745  {
2746  m_ROSpecID = value;
2747  }
2748 
2749 
2750 
2751 };
2752 
2753 
2784 class CDELETE_ROSPEC_RESPONSE : public CMessage
2785 {
2786  public:
2787  CDELETE_ROSPEC_RESPONSE (void);
2788  ~CDELETE_ROSPEC_RESPONSE (void);
2789 
2792 
2793  static const CFieldDescriptor * const
2794  s_apFieldDescriptorTable[];
2795 
2796  static const CTypeDescriptor
2797  s_typeDescriptor;
2798 
2799  void
2800  decodeFields (
2801  CDecoderStream * pDecoderStream);
2802 
2803  void
2804  assimilateSubParameters (
2805  CErrorDetails * pError);
2806 
2807  void
2808  encode (
2809  CEncoderStream * pEncoderStream) const;
2810 
2811 
2812 
2813  static CElement *
2814  s_construct (void);
2815 
2816  static void
2817  s_decodeFields (
2818  CDecoderStream * pDecoderStream,
2819  CElement * pElement);
2821 
2822 
2823 
2824  protected:
2825  CLLRPStatus * m_pLLRPStatus;
2826 
2827  public:
2829  inline CLLRPStatus *
2831  {
2832  return m_pLLRPStatus;
2833  }
2834 
2836  EResultCode
2837  setLLRPStatus (
2838  CLLRPStatus * pValue);
2839 
2840 
2841 };
2842 
2843 
2877 class CSTART_ROSPEC : public CMessage
2878 {
2879  public:
2880  CSTART_ROSPEC (void);
2881  ~CSTART_ROSPEC (void);
2882 
2885 
2886  static const CFieldDescriptor * const
2887  s_apFieldDescriptorTable[];
2888 
2889  static const CTypeDescriptor
2890  s_typeDescriptor;
2891 
2892  void
2893  decodeFields (
2894  CDecoderStream * pDecoderStream);
2895 
2896  void
2897  assimilateSubParameters (
2898  CErrorDetails * pError);
2899 
2900  void
2901  encode (
2902  CEncoderStream * pEncoderStream) const;
2903 
2904 
2905 
2906  static CElement *
2907  s_construct (void);
2908 
2909  static void
2910  s_decodeFields (
2911  CDecoderStream * pDecoderStream,
2912  CElement * pElement);
2914 
2915 
2916  protected:
2917  llrp_u32_t m_ROSpecID;
2918 
2921  public:
2922  static const CFieldDescriptor
2923  s_fdROSpecID;
2925 
2927  inline llrp_u32_t
2929  {
2930  return m_ROSpecID;
2931  }
2932 
2934  inline void
2936  llrp_u32_t value)
2937  {
2938  m_ROSpecID = value;
2939  }
2940 
2941 
2942 
2943 };
2944 
2945 
2976 class CSTART_ROSPEC_RESPONSE : public CMessage
2977 {
2978  public:
2979  CSTART_ROSPEC_RESPONSE (void);
2980  ~CSTART_ROSPEC_RESPONSE (void);
2981 
2984 
2985  static const CFieldDescriptor * const
2986  s_apFieldDescriptorTable[];
2987 
2988  static const CTypeDescriptor
2989  s_typeDescriptor;
2990 
2991  void
2992  decodeFields (
2993  CDecoderStream * pDecoderStream);
2994 
2995  void
2996  assimilateSubParameters (
2997  CErrorDetails * pError);
2998 
2999  void
3000  encode (
3001  CEncoderStream * pEncoderStream) const;
3002 
3003 
3004 
3005  static CElement *
3006  s_construct (void);
3007 
3008  static void
3009  s_decodeFields (
3010  CDecoderStream * pDecoderStream,
3011  CElement * pElement);
3013 
3014 
3015 
3016  protected:
3017  CLLRPStatus * m_pLLRPStatus;
3018 
3019  public:
3021  inline CLLRPStatus *
3023  {
3024  return m_pLLRPStatus;
3025  }
3026 
3028  EResultCode
3029  setLLRPStatus (
3030  CLLRPStatus * pValue);
3031 
3032 
3033 };
3034 
3035 
3069 class CSTOP_ROSPEC : public CMessage
3070 {
3071  public:
3072  CSTOP_ROSPEC (void);
3073  ~CSTOP_ROSPEC (void);
3074 
3077 
3078  static const CFieldDescriptor * const
3079  s_apFieldDescriptorTable[];
3080 
3081  static const CTypeDescriptor
3082  s_typeDescriptor;
3083 
3084  void
3085  decodeFields (
3086  CDecoderStream * pDecoderStream);
3087 
3088  void
3089  assimilateSubParameters (
3090  CErrorDetails * pError);
3091 
3092  void
3093  encode (
3094  CEncoderStream * pEncoderStream) const;
3095 
3096 
3097 
3098  static CElement *
3099  s_construct (void);
3100 
3101  static void
3102  s_decodeFields (
3103  CDecoderStream * pDecoderStream,
3104  CElement * pElement);
3106 
3107 
3108  protected:
3109  llrp_u32_t m_ROSpecID;
3110 
3113  public:
3114  static const CFieldDescriptor
3115  s_fdROSpecID;
3117 
3119  inline llrp_u32_t
3121  {
3122  return m_ROSpecID;
3123  }
3124 
3126  inline void
3128  llrp_u32_t value)
3129  {
3130  m_ROSpecID = value;
3131  }
3132 
3133 
3134 
3135 };
3136 
3137 
3168 class CSTOP_ROSPEC_RESPONSE : public CMessage
3169 {
3170  public:
3171  CSTOP_ROSPEC_RESPONSE (void);
3172  ~CSTOP_ROSPEC_RESPONSE (void);
3173 
3176 
3177  static const CFieldDescriptor * const
3178  s_apFieldDescriptorTable[];
3179 
3180  static const CTypeDescriptor
3181  s_typeDescriptor;
3182 
3183  void
3184  decodeFields (
3185  CDecoderStream * pDecoderStream);
3186 
3187  void
3188  assimilateSubParameters (
3189  CErrorDetails * pError);
3190 
3191  void
3192  encode (
3193  CEncoderStream * pEncoderStream) const;
3194 
3195 
3196 
3197  static CElement *
3198  s_construct (void);
3199 
3200  static void
3201  s_decodeFields (
3202  CDecoderStream * pDecoderStream,
3203  CElement * pElement);
3205 
3206 
3207 
3208  protected:
3209  CLLRPStatus * m_pLLRPStatus;
3210 
3211  public:
3213  inline CLLRPStatus *
3215  {
3216  return m_pLLRPStatus;
3217  }
3218 
3220  EResultCode
3221  setLLRPStatus (
3222  CLLRPStatus * pValue);
3223 
3224 
3225 };
3226 
3227 
3261 class CENABLE_ROSPEC : public CMessage
3262 {
3263  public:
3264  CENABLE_ROSPEC (void);
3265  ~CENABLE_ROSPEC (void);
3266 
3269 
3270  static const CFieldDescriptor * const
3271  s_apFieldDescriptorTable[];
3272 
3273  static const CTypeDescriptor
3274  s_typeDescriptor;
3275 
3276  void
3277  decodeFields (
3278  CDecoderStream * pDecoderStream);
3279 
3280  void
3281  assimilateSubParameters (
3282  CErrorDetails * pError);
3283 
3284  void
3285  encode (
3286  CEncoderStream * pEncoderStream) const;
3287 
3288 
3289 
3290  static CElement *
3291  s_construct (void);
3292 
3293  static void
3294  s_decodeFields (
3295  CDecoderStream * pDecoderStream,
3296  CElement * pElement);
3298 
3299 
3300  protected:
3301  llrp_u32_t m_ROSpecID;
3302 
3305  public:
3306  static const CFieldDescriptor
3307  s_fdROSpecID;
3309 
3311  inline llrp_u32_t
3313  {
3314  return m_ROSpecID;
3315  }
3316 
3318  inline void
3320  llrp_u32_t value)
3321  {
3322  m_ROSpecID = value;
3323  }
3324 
3325 
3326 
3327 };
3328 
3329 
3360 class CENABLE_ROSPEC_RESPONSE : public CMessage
3361 {
3362  public:
3363  CENABLE_ROSPEC_RESPONSE (void);
3364  ~CENABLE_ROSPEC_RESPONSE (void);
3365 
3368 
3369  static const CFieldDescriptor * const
3370  s_apFieldDescriptorTable[];
3371 
3372  static const CTypeDescriptor
3373  s_typeDescriptor;
3374 
3375  void
3376  decodeFields (
3377  CDecoderStream * pDecoderStream);
3378 
3379  void
3380  assimilateSubParameters (
3381  CErrorDetails * pError);
3382 
3383  void
3384  encode (
3385  CEncoderStream * pEncoderStream) const;
3386 
3387 
3388 
3389  static CElement *
3390  s_construct (void);
3391 
3392  static void
3393  s_decodeFields (
3394  CDecoderStream * pDecoderStream,
3395  CElement * pElement);
3397 
3398 
3399 
3400  protected:
3401  CLLRPStatus * m_pLLRPStatus;
3402 
3403  public:
3405  inline CLLRPStatus *
3407  {
3408  return m_pLLRPStatus;
3409  }
3410 
3412  EResultCode
3413  setLLRPStatus (
3414  CLLRPStatus * pValue);
3415 
3416 
3417 };
3418 
3419 
3453 class CDISABLE_ROSPEC : public CMessage
3454 {
3455  public:
3456  CDISABLE_ROSPEC (void);
3457  ~CDISABLE_ROSPEC (void);
3458 
3461 
3462  static const CFieldDescriptor * const
3463  s_apFieldDescriptorTable[];
3464 
3465  static const CTypeDescriptor
3466  s_typeDescriptor;
3467 
3468  void
3469  decodeFields (
3470  CDecoderStream * pDecoderStream);
3471 
3472  void
3473  assimilateSubParameters (
3474  CErrorDetails * pError);
3475 
3476  void
3477  encode (
3478  CEncoderStream * pEncoderStream) const;
3479 
3480 
3481 
3482  static CElement *
3483  s_construct (void);
3484 
3485  static void
3486  s_decodeFields (
3487  CDecoderStream * pDecoderStream,
3488  CElement * pElement);
3490 
3491 
3492  protected:
3493  llrp_u32_t m_ROSpecID;
3494 
3497  public:
3498  static const CFieldDescriptor
3499  s_fdROSpecID;
3501 
3503  inline llrp_u32_t
3505  {
3506  return m_ROSpecID;
3507  }
3508 
3510  inline void
3512  llrp_u32_t value)
3513  {
3514  m_ROSpecID = value;
3515  }
3516 
3517 
3518 
3519 };
3520 
3521 
3552 class CDISABLE_ROSPEC_RESPONSE : public CMessage
3553 {
3554  public:
3555  CDISABLE_ROSPEC_RESPONSE (void);
3556  ~CDISABLE_ROSPEC_RESPONSE (void);
3557 
3560 
3561  static const CFieldDescriptor * const
3562  s_apFieldDescriptorTable[];
3563 
3564  static const CTypeDescriptor
3565  s_typeDescriptor;
3566 
3567  void
3568  decodeFields (
3569  CDecoderStream * pDecoderStream);
3570 
3571  void
3572  assimilateSubParameters (
3573  CErrorDetails * pError);
3574 
3575  void
3576  encode (
3577  CEncoderStream * pEncoderStream) const;
3578 
3579 
3580 
3581  static CElement *
3582  s_construct (void);
3583 
3584  static void
3585  s_decodeFields (
3586  CDecoderStream * pDecoderStream,
3587  CElement * pElement);
3589 
3590 
3591 
3592  protected:
3593  CLLRPStatus * m_pLLRPStatus;
3594 
3595  public:
3597  inline CLLRPStatus *
3599  {
3600  return m_pLLRPStatus;
3601  }
3602 
3604  EResultCode
3605  setLLRPStatus (
3606  CLLRPStatus * pValue);
3607 
3608 
3609 };
3610 
3611 
3641 class CGET_ROSPECS : public CMessage
3642 {
3643  public:
3644  CGET_ROSPECS (void);
3645  ~CGET_ROSPECS (void);
3646 
3649 
3650  static const CFieldDescriptor * const
3651  s_apFieldDescriptorTable[];
3652 
3653  static const CTypeDescriptor
3654  s_typeDescriptor;
3655 
3656  void
3657  decodeFields (
3658  CDecoderStream * pDecoderStream);
3659 
3660  void
3661  assimilateSubParameters (
3662  CErrorDetails * pError);
3663 
3664  void
3665  encode (
3666  CEncoderStream * pEncoderStream) const;
3667 
3668 
3669 
3670  static CElement *
3671  s_construct (void);
3672 
3673  static void
3674  s_decodeFields (
3675  CDecoderStream * pDecoderStream,
3676  CElement * pElement);
3678 
3679 
3680 
3681 };
3682 
3683 
3715 class CGET_ROSPECS_RESPONSE : public CMessage
3716 {
3717  public:
3718  CGET_ROSPECS_RESPONSE (void);
3719  ~CGET_ROSPECS_RESPONSE (void);
3720 
3723 
3724  static const CFieldDescriptor * const
3725  s_apFieldDescriptorTable[];
3726 
3727  static const CTypeDescriptor
3728  s_typeDescriptor;
3729 
3730  void
3731  decodeFields (
3732  CDecoderStream * pDecoderStream);
3733 
3734  void
3735  assimilateSubParameters (
3736  CErrorDetails * pError);
3737 
3738  void
3739  encode (
3740  CEncoderStream * pEncoderStream) const;
3741 
3742 
3743 
3744  static CElement *
3745  s_construct (void);
3746 
3747  static void
3748  s_decodeFields (
3749  CDecoderStream * pDecoderStream,
3750  CElement * pElement);
3752 
3753 
3754 
3755  protected:
3756  CLLRPStatus * m_pLLRPStatus;
3757 
3758  public:
3760  inline CLLRPStatus *
3762  {
3763  return m_pLLRPStatus;
3764  }
3765 
3767  EResultCode
3768  setLLRPStatus (
3769  CLLRPStatus * pValue);
3770 
3771 
3772  protected:
3773  std::list<CROSpec *> m_listROSpec;
3774 
3775  public:
3777  inline std::list<CROSpec *>::iterator
3779  {
3780  return m_listROSpec.begin();
3781  }
3782 
3784  inline std::list<CROSpec *>::iterator
3785  endROSpec (void)
3786  {
3787  return m_listROSpec.end();
3788  }
3789 
3791  inline void
3793  {
3794  clearSubParameterList ((tListOfParameters *) &m_listROSpec);
3795  }
3796 
3798  inline int
3800  {
3801  return (int) (m_listROSpec.size());
3802  }
3803 
3804  EResultCode
3806  addROSpec (
3807  CROSpec * pValue);
3808 
3809 
3810 };
3811 
3812 
3852 class CADD_ACCESSSPEC : public CMessage
3853 {
3854  public:
3855  CADD_ACCESSSPEC (void);
3856  ~CADD_ACCESSSPEC (void);
3857 
3860 
3861  static const CFieldDescriptor * const
3862  s_apFieldDescriptorTable[];
3863 
3864  static const CTypeDescriptor
3865  s_typeDescriptor;
3866 
3867  void
3868  decodeFields (
3869  CDecoderStream * pDecoderStream);
3870 
3871  void
3872  assimilateSubParameters (
3873  CErrorDetails * pError);
3874 
3875  void
3876  encode (
3877  CEncoderStream * pEncoderStream) const;
3878 
3879 
3880 
3881  static CElement *
3882  s_construct (void);
3883 
3884  static void
3885  s_decodeFields (
3886  CDecoderStream * pDecoderStream,
3887  CElement * pElement);
3889 
3890 
3891 
3892  protected:
3893  CAccessSpec * m_pAccessSpec;
3894 
3895  public:
3897  inline CAccessSpec *
3899  {
3900  return m_pAccessSpec;
3901  }
3902 
3904  EResultCode
3905  setAccessSpec (
3906  CAccessSpec * pValue);
3907 
3908 
3909 };
3910 
3911 
3942 class CADD_ACCESSSPEC_RESPONSE : public CMessage
3943 {
3944  public:
3945  CADD_ACCESSSPEC_RESPONSE (void);
3946  ~CADD_ACCESSSPEC_RESPONSE (void);
3947 
3950 
3951  static const CFieldDescriptor * const
3952  s_apFieldDescriptorTable[];
3953 
3954  static const CTypeDescriptor
3955  s_typeDescriptor;
3956 
3957  void
3958  decodeFields (
3959  CDecoderStream * pDecoderStream);
3960 
3961  void
3962  assimilateSubParameters (
3963  CErrorDetails * pError);
3964 
3965  void
3966  encode (
3967  CEncoderStream * pEncoderStream) const;
3968 
3969 
3970 
3971  static CElement *
3972  s_construct (void);
3973 
3974  static void
3975  s_decodeFields (
3976  CDecoderStream * pDecoderStream,
3977  CElement * pElement);
3979 
3980 
3981 
3982  protected:
3983  CLLRPStatus * m_pLLRPStatus;
3984 
3985  public:
3987  inline CLLRPStatus *
3989  {
3990  return m_pLLRPStatus;
3991  }
3992 
3994  EResultCode
3995  setLLRPStatus (
3996  CLLRPStatus * pValue);
3997 
3998 
3999 };
4000 
4001 
4035 class CDELETE_ACCESSSPEC : public CMessage
4036 {
4037  public:
4038  CDELETE_ACCESSSPEC (void);
4039  ~CDELETE_ACCESSSPEC (void);
4040 
4043 
4044  static const CFieldDescriptor * const
4045  s_apFieldDescriptorTable[];
4046 
4047  static const CTypeDescriptor
4048  s_typeDescriptor;
4049 
4050  void
4051  decodeFields (
4052  CDecoderStream * pDecoderStream);
4053 
4054  void
4055  assimilateSubParameters (
4056  CErrorDetails * pError);
4057 
4058  void
4059  encode (
4060  CEncoderStream * pEncoderStream) const;
4061 
4062 
4063 
4064  static CElement *
4065  s_construct (void);
4066 
4067  static void
4068  s_decodeFields (
4069  CDecoderStream * pDecoderStream,
4070  CElement * pElement);
4072 
4073 
4074  protected:
4075  llrp_u32_t m_AccessSpecID;
4076 
4079  public:
4080  static const CFieldDescriptor
4081  s_fdAccessSpecID;
4083 
4085  inline llrp_u32_t
4087  {
4088  return m_AccessSpecID;
4089  }
4090 
4092  inline void
4094  llrp_u32_t value)
4095  {
4096  m_AccessSpecID = value;
4097  }
4098 
4099 
4100 
4101 };
4102 
4103 
4134 class CDELETE_ACCESSSPEC_RESPONSE : public CMessage
4135 {
4136  public:
4139 
4142 
4143  static const CFieldDescriptor * const
4144  s_apFieldDescriptorTable[];
4145 
4146  static const CTypeDescriptor
4147  s_typeDescriptor;
4148 
4149  void
4150  decodeFields (
4151  CDecoderStream * pDecoderStream);
4152 
4153  void
4154  assimilateSubParameters (
4155  CErrorDetails * pError);
4156 
4157  void
4158  encode (
4159  CEncoderStream * pEncoderStream) const;
4160 
4161 
4162 
4163  static CElement *
4164  s_construct (void);
4165 
4166  static void
4167  s_decodeFields (
4168  CDecoderStream * pDecoderStream,
4169  CElement * pElement);
4171 
4172 
4173 
4174  protected:
4175  CLLRPStatus * m_pLLRPStatus;
4176 
4177  public:
4179  inline CLLRPStatus *
4181  {
4182  return m_pLLRPStatus;
4183  }
4184 
4186  EResultCode
4187  setLLRPStatus (
4188  CLLRPStatus * pValue);
4189 
4190 
4191 };
4192 
4193 
4227 class CENABLE_ACCESSSPEC : public CMessage
4228 {
4229  public:
4230  CENABLE_ACCESSSPEC (void);
4231  ~CENABLE_ACCESSSPEC (void);
4232 
4235 
4236  static const CFieldDescriptor * const
4237  s_apFieldDescriptorTable[];
4238 
4239  static const CTypeDescriptor
4240  s_typeDescriptor;
4241 
4242  void
4243  decodeFields (
4244  CDecoderStream * pDecoderStream);
4245 
4246  void
4247  assimilateSubParameters (
4248  CErrorDetails * pError);
4249 
4250  void
4251  encode (
4252  CEncoderStream * pEncoderStream) const;
4253 
4254 
4255 
4256  static CElement *
4257  s_construct (void);
4258 
4259  static void
4260  s_decodeFields (
4261  CDecoderStream * pDecoderStream,
4262  CElement * pElement);
4264 
4265 
4266  protected:
4267  llrp_u32_t m_AccessSpecID;
4268 
4271  public:
4272  static const CFieldDescriptor
4273  s_fdAccessSpecID;
4275 
4277  inline llrp_u32_t
4279  {
4280  return m_AccessSpecID;
4281  }
4282 
4284  inline void
4286  llrp_u32_t value)
4287  {
4288  m_AccessSpecID = value;
4289  }
4290 
4291 
4292 
4293 };
4294 
4295 
4326 class CENABLE_ACCESSSPEC_RESPONSE : public CMessage
4327 {
4328  public:
4331 
4334 
4335  static const CFieldDescriptor * const
4336  s_apFieldDescriptorTable[];
4337 
4338  static const CTypeDescriptor
4339  s_typeDescriptor;
4340 
4341  void
4342  decodeFields (
4343  CDecoderStream * pDecoderStream);
4344 
4345  void
4346  assimilateSubParameters (
4347  CErrorDetails * pError);
4348 
4349  void
4350  encode (
4351  CEncoderStream * pEncoderStream) const;
4352 
4353 
4354 
4355  static CElement *
4356  s_construct (void);
4357 
4358  static void
4359  s_decodeFields (
4360  CDecoderStream * pDecoderStream,
4361  CElement * pElement);
4363 
4364 
4365 
4366  protected:
4367  CLLRPStatus * m_pLLRPStatus;
4368 
4369  public:
4371  inline CLLRPStatus *
4373  {
4374  return m_pLLRPStatus;
4375  }
4376 
4378  EResultCode
4379  setLLRPStatus (
4380  CLLRPStatus * pValue);
4381 
4382 
4383 };
4384 
4385 
4419 class CDISABLE_ACCESSSPEC : public CMessage
4420 {
4421  public:
4422  CDISABLE_ACCESSSPEC (void);
4423  ~CDISABLE_ACCESSSPEC (void);
4424 
4427 
4428  static const CFieldDescriptor * const
4429  s_apFieldDescriptorTable[];
4430 
4431  static const CTypeDescriptor
4432  s_typeDescriptor;
4433 
4434  void
4435  decodeFields (
4436  CDecoderStream * pDecoderStream);
4437 
4438  void
4439  assimilateSubParameters (
4440  CErrorDetails * pError);
4441 
4442  void
4443  encode (
4444  CEncoderStream * pEncoderStream) const;
4445 
4446 
4447 
4448  static CElement *
4449  s_construct (void);
4450 
4451  static void
4452  s_decodeFields (
4453  CDecoderStream * pDecoderStream,
4454  CElement * pElement);
4456 
4457 
4458  protected:
4459  llrp_u32_t m_AccessSpecID;
4460 
4463  public:
4464  static const CFieldDescriptor
4465  s_fdAccessSpecID;
4467 
4469  inline llrp_u32_t
4471  {
4472  return m_AccessSpecID;
4473  }
4474 
4476  inline void
4478  llrp_u32_t value)
4479  {
4480  m_AccessSpecID = value;
4481  }
4482 
4483 
4484 
4485 };
4486 
4487 
4518 class CDISABLE_ACCESSSPEC_RESPONSE : public CMessage
4519 {
4520  public:
4523 
4526 
4527  static const CFieldDescriptor * const
4528  s_apFieldDescriptorTable[];
4529 
4530  static const CTypeDescriptor
4531  s_typeDescriptor;
4532 
4533  void
4534  decodeFields (
4535  CDecoderStream * pDecoderStream);
4536 
4537  void
4538  assimilateSubParameters (
4539  CErrorDetails * pError);
4540 
4541  void
4542  encode (
4543  CEncoderStream * pEncoderStream) const;
4544 
4545 
4546 
4547  static CElement *
4548  s_construct (void);
4549 
4550  static void
4551  s_decodeFields (
4552  CDecoderStream * pDecoderStream,
4553  CElement * pElement);
4555 
4556 
4557 
4558  protected:
4559  CLLRPStatus * m_pLLRPStatus;
4560 
4561  public:
4563  inline CLLRPStatus *
4565  {
4566  return m_pLLRPStatus;
4567  }
4568 
4570  EResultCode
4571  setLLRPStatus (
4572  CLLRPStatus * pValue);
4573 
4574 
4575 };
4576 
4577 
4607 class CGET_ACCESSSPECS : public CMessage
4608 {
4609  public:
4610  CGET_ACCESSSPECS (void);
4611  ~CGET_ACCESSSPECS (void);
4612 
4615 
4616  static const CFieldDescriptor * const
4617  s_apFieldDescriptorTable[];
4618 
4619  static const CTypeDescriptor
4620  s_typeDescriptor;
4621 
4622  void
4623  decodeFields (
4624  CDecoderStream * pDecoderStream);
4625 
4626  void
4627  assimilateSubParameters (
4628  CErrorDetails * pError);
4629 
4630  void
4631  encode (
4632  CEncoderStream * pEncoderStream) const;
4633 
4634 
4635 
4636  static CElement *
4637  s_construct (void);
4638 
4639  static void
4640  s_decodeFields (
4641  CDecoderStream * pDecoderStream,
4642  CElement * pElement);
4644 
4645 
4646 
4647 };
4648 
4649 
4681 class CGET_ACCESSSPECS_RESPONSE : public CMessage
4682 {
4683  public:
4685  ~CGET_ACCESSSPECS_RESPONSE (void);
4686 
4689 
4690  static const CFieldDescriptor * const
4691  s_apFieldDescriptorTable[];
4692 
4693  static const CTypeDescriptor
4694  s_typeDescriptor;
4695 
4696  void
4697  decodeFields (
4698  CDecoderStream * pDecoderStream);
4699 
4700  void
4701  assimilateSubParameters (
4702  CErrorDetails * pError);
4703 
4704  void
4705  encode (
4706  CEncoderStream * pEncoderStream) const;
4707 
4708 
4709 
4710  static CElement *
4711  s_construct (void);
4712 
4713  static void
4714  s_decodeFields (
4715  CDecoderStream * pDecoderStream,
4716  CElement * pElement);
4718 
4719 
4720 
4721  protected:
4722  CLLRPStatus * m_pLLRPStatus;
4723 
4724  public:
4726  inline CLLRPStatus *
4728  {
4729  return m_pLLRPStatus;
4730  }
4731 
4733  EResultCode
4734  setLLRPStatus (
4735  CLLRPStatus * pValue);
4736 
4737 
4738  protected:
4739  std::list<CAccessSpec *> m_listAccessSpec;
4740 
4741  public:
4743  inline std::list<CAccessSpec *>::iterator
4745  {
4746  return m_listAccessSpec.begin();
4747  }
4748 
4750  inline std::list<CAccessSpec *>::iterator
4752  {
4753  return m_listAccessSpec.end();
4754  }
4755 
4757  inline void
4759  {
4760  clearSubParameterList ((tListOfParameters *) &m_listAccessSpec);
4761  }
4762 
4764  inline int
4766  {
4767  return (int) (m_listAccessSpec.size());
4768  }
4769 
4770  EResultCode
4772  addAccessSpec (
4773  CAccessSpec * pValue);
4774 
4775 
4776 };
4777 
4778 
4809 class CCLIENT_REQUEST_OP : public CMessage
4810 {
4811  public:
4812  CCLIENT_REQUEST_OP (void);
4813  ~CCLIENT_REQUEST_OP (void);
4814 
4817 
4818  static const CFieldDescriptor * const
4819  s_apFieldDescriptorTable[];
4820 
4821  static const CTypeDescriptor
4822  s_typeDescriptor;
4823 
4824  void
4825  decodeFields (
4826  CDecoderStream * pDecoderStream);
4827 
4828  void
4829  assimilateSubParameters (
4830  CErrorDetails * pError);
4831 
4832  void
4833  encode (
4834  CEncoderStream * pEncoderStream) const;
4835 
4836 
4837 
4838  static CElement *
4839  s_construct (void);
4840 
4841  static void
4842  s_decodeFields (
4843  CDecoderStream * pDecoderStream,
4844  CElement * pElement);
4846 
4847 
4848 
4849  protected:
4850  CTagReportData * m_pTagReportData;
4851 
4852  public:
4854  inline CTagReportData *
4856  {
4857  return m_pTagReportData;
4858  }
4859 
4861  EResultCode
4862  setTagReportData (
4863  CTagReportData * pValue);
4864 
4865 
4866 };
4867 
4868 
4899 class CCLIENT_REQUEST_OP_RESPONSE : public CMessage
4900 {
4901  public:
4904 
4907 
4908  static const CFieldDescriptor * const
4909  s_apFieldDescriptorTable[];
4910 
4911  static const CTypeDescriptor
4912  s_typeDescriptor;
4913 
4914  void
4915  decodeFields (
4916  CDecoderStream * pDecoderStream);
4917 
4918  void
4919  assimilateSubParameters (
4920  CErrorDetails * pError);
4921 
4922  void
4923  encode (
4924  CEncoderStream * pEncoderStream) const;
4925 
4926 
4927 
4928  static CElement *
4929  s_construct (void);
4930 
4931  static void
4932  s_decodeFields (
4933  CDecoderStream * pDecoderStream,
4934  CElement * pElement);
4936 
4937 
4938 
4939  protected:
4940  CClientRequestResponse * m_pClientRequestResponse;
4941 
4942  public:
4944  inline CClientRequestResponse *
4946  {
4947  return m_pClientRequestResponse;
4948  }
4949 
4951  EResultCode
4952  setClientRequestResponse (
4953  CClientRequestResponse * pValue);
4954 
4955 
4956 };
4957 
4958 
4993 class CGET_READER_CONFIG : public CMessage
4994 {
4995  public:
4996  CGET_READER_CONFIG (void);
4997  ~CGET_READER_CONFIG (void);
4998 
5001 
5002  static const CFieldDescriptor * const
5003  s_apFieldDescriptorTable[];
5004 
5005  static const CTypeDescriptor
5006  s_typeDescriptor;
5007 
5008  void
5009  decodeFields (
5010  CDecoderStream * pDecoderStream);
5011 
5012  void
5013  assimilateSubParameters (
5014  CErrorDetails * pError);
5015 
5016  void
5017  encode (
5018  CEncoderStream * pEncoderStream) const;
5019 
5020 
5021 
5022  static CElement *
5023  s_construct (void);
5024 
5025  static void
5026  s_decodeFields (
5027  CDecoderStream * pDecoderStream,
5028  CElement * pElement);
5030 
5031 
5032  protected:
5033  llrp_u16_t m_AntennaID;
5034 
5037  public:
5038  static const CFieldDescriptor
5039  s_fdAntennaID;
5041 
5043  inline llrp_u16_t
5045  {
5046  return m_AntennaID;
5047  }
5048 
5050  inline void
5052  llrp_u16_t value)
5053  {
5054  m_AntennaID = value;
5055  }
5056 
5057 
5058  protected:
5059  EGetReaderConfigRequestedData m_eRequestedData;
5060 
5063  public:
5064  static const CFieldDescriptor
5065  s_fdRequestedData;
5067 
5069  inline EGetReaderConfigRequestedData
5071  {
5072  return m_eRequestedData;
5073  }
5074 
5076  inline void
5078  EGetReaderConfigRequestedData value)
5079  {
5080  m_eRequestedData = value;
5081  }
5082 
5083 
5084  protected:
5085  llrp_u16_t m_GPIPortNum;
5086 
5089  public:
5090  static const CFieldDescriptor
5091  s_fdGPIPortNum;
5093 
5095  inline llrp_u16_t
5097  {
5098  return m_GPIPortNum;
5099  }
5100 
5102  inline void
5104  llrp_u16_t value)
5105  {
5106  m_GPIPortNum = value;
5107  }
5108 
5109 
5110  protected:
5111  llrp_u16_t m_GPOPortNum;
5112 
5115  public:
5116  static const CFieldDescriptor
5117  s_fdGPOPortNum;
5119 
5121  inline llrp_u16_t
5123  {
5124  return m_GPOPortNum;
5125  }
5126 
5128  inline void
5130  llrp_u16_t value)
5131  {
5132  m_GPOPortNum = value;
5133  }
5134 
5135 
5136 
5137  protected:
5138  std::list<CParameter *> m_listCustom;
5139 
5140  public:
5142  inline std::list<CParameter *>::iterator
5144  {
5145  return m_listCustom.begin();
5146  }
5147 
5149  inline std::list<CParameter *>::iterator
5150  endCustom (void)
5151  {
5152  return m_listCustom.end();
5153  }
5154 
5156  inline void
5158  {
5159  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5160  }
5161 
5163  inline int
5165  {
5166  return (int) (m_listCustom.size());
5167  }
5168 
5169  EResultCode
5171  addCustom (
5172  CParameter * pValue);
5173 
5174 
5175 };
5176 
5177 
5238 class CGET_READER_CONFIG_RESPONSE : public CMessage
5239 {
5240  public:
5243 
5246 
5247  static const CFieldDescriptor * const
5248  s_apFieldDescriptorTable[];
5249 
5250  static const CTypeDescriptor
5251  s_typeDescriptor;
5252 
5253  void
5254  decodeFields (
5255  CDecoderStream * pDecoderStream);
5256 
5257  void
5258  assimilateSubParameters (
5259  CErrorDetails * pError);
5260 
5261  void
5262  encode (
5263  CEncoderStream * pEncoderStream) const;
5264 
5265 
5266 
5267  static CElement *
5268  s_construct (void);
5269 
5270  static void
5271  s_decodeFields (
5272  CDecoderStream * pDecoderStream,
5273  CElement * pElement);
5275 
5276 
5277 
5278  protected:
5279  CLLRPStatus * m_pLLRPStatus;
5280 
5281  public:
5283  inline CLLRPStatus *
5285  {
5286  return m_pLLRPStatus;
5287  }
5288 
5290  EResultCode
5291  setLLRPStatus (
5292  CLLRPStatus * pValue);
5293 
5294 
5295  protected:
5296  CIdentification * m_pIdentification;
5297 
5298  public:
5300  inline CIdentification *
5302  {
5303  return m_pIdentification;
5304  }
5305 
5307  EResultCode
5308  setIdentification (
5309  CIdentification * pValue);
5310 
5311 
5312  protected:
5313  std::list<CAntennaProperties *> m_listAntennaProperties;
5314 
5315  public:
5317  inline std::list<CAntennaProperties *>::iterator
5319  {
5320  return m_listAntennaProperties.begin();
5321  }
5322 
5324  inline std::list<CAntennaProperties *>::iterator
5326  {
5327  return m_listAntennaProperties.end();
5328  }
5329 
5331  inline void
5333  {
5334  clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties);
5335  }
5336 
5338  inline int
5340  {
5341  return (int) (m_listAntennaProperties.size());
5342  }
5343 
5344  EResultCode
5346  addAntennaProperties (
5347  CAntennaProperties * pValue);
5348 
5349 
5350  protected:
5351  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
5352 
5353  public:
5355  inline std::list<CAntennaConfiguration *>::iterator
5357  {
5358  return m_listAntennaConfiguration.begin();
5359  }
5360 
5362  inline std::list<CAntennaConfiguration *>::iterator
5364  {
5365  return m_listAntennaConfiguration.end();
5366  }
5367 
5369  inline void
5371  {
5372  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
5373  }
5374 
5376  inline int
5378  {
5379  return (int) (m_listAntennaConfiguration.size());
5380  }
5381 
5382  EResultCode
5384  addAntennaConfiguration (
5385  CAntennaConfiguration * pValue);
5386 
5387 
5388  protected:
5389  CReaderEventNotificationSpec * m_pReaderEventNotificationSpec;
5390 
5391  public:
5395  {
5396  return m_pReaderEventNotificationSpec;
5397  }
5398 
5400  EResultCode
5401  setReaderEventNotificationSpec (
5402  CReaderEventNotificationSpec * pValue);
5403 
5404 
5405  protected:
5406  CROReportSpec * m_pROReportSpec;
5407 
5408  public:
5410  inline CROReportSpec *
5412  {
5413  return m_pROReportSpec;
5414  }
5415 
5417  EResultCode
5418  setROReportSpec (
5419  CROReportSpec * pValue);
5420 
5421 
5422  protected:
5423  CAccessReportSpec * m_pAccessReportSpec;
5424 
5425  public:
5427  inline CAccessReportSpec *
5429  {
5430  return m_pAccessReportSpec;
5431  }
5432 
5434  EResultCode
5435  setAccessReportSpec (
5436  CAccessReportSpec * pValue);
5437 
5438 
5439  protected:
5440  CLLRPConfigurationStateValue * m_pLLRPConfigurationStateValue;
5441 
5442  public:
5446  {
5447  return m_pLLRPConfigurationStateValue;
5448  }
5449 
5451  EResultCode
5452  setLLRPConfigurationStateValue (
5453  CLLRPConfigurationStateValue * pValue);
5454 
5455 
5456  protected:
5457  CKeepaliveSpec * m_pKeepaliveSpec;
5458 
5459  public:
5461  inline CKeepaliveSpec *
5463  {
5464  return m_pKeepaliveSpec;
5465  }
5466 
5468  EResultCode
5469  setKeepaliveSpec (
5470  CKeepaliveSpec * pValue);
5471 
5472 
5473  protected:
5474  std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState;
5475 
5476  public:
5478  inline std::list<CGPIPortCurrentState *>::iterator
5480  {
5481  return m_listGPIPortCurrentState.begin();
5482  }
5483 
5485  inline std::list<CGPIPortCurrentState *>::iterator
5487  {
5488  return m_listGPIPortCurrentState.end();
5489  }
5490 
5492  inline void
5494  {
5495  clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState);
5496  }
5497 
5499  inline int
5501  {
5502  return (int) (m_listGPIPortCurrentState.size());
5503  }
5504 
5505  EResultCode
5507  addGPIPortCurrentState (
5508  CGPIPortCurrentState * pValue);
5509 
5510 
5511  protected:
5512  std::list<CGPOWriteData *> m_listGPOWriteData;
5513 
5514  public:
5516  inline std::list<CGPOWriteData *>::iterator
5518  {
5519  return m_listGPOWriteData.begin();
5520  }
5521 
5523  inline std::list<CGPOWriteData *>::iterator
5525  {
5526  return m_listGPOWriteData.end();
5527  }
5528 
5530  inline void
5532  {
5533  clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData);
5534  }
5535 
5537  inline int
5539  {
5540  return (int) (m_listGPOWriteData.size());
5541  }
5542 
5543  EResultCode
5545  addGPOWriteData (
5546  CGPOWriteData * pValue);
5547 
5548 
5549  protected:
5550  CEventsAndReports * m_pEventsAndReports;
5551 
5552  public:
5554  inline CEventsAndReports *
5556  {
5557  return m_pEventsAndReports;
5558  }
5559 
5561  EResultCode
5562  setEventsAndReports (
5563  CEventsAndReports * pValue);
5564 
5565 
5566  protected:
5567  std::list<CParameter *> m_listCustom;
5568 
5569  public:
5571  inline std::list<CParameter *>::iterator
5573  {
5574  return m_listCustom.begin();
5575  }
5576 
5578  inline std::list<CParameter *>::iterator
5579  endCustom (void)
5580  {
5581  return m_listCustom.end();
5582  }
5583 
5585  inline void
5587  {
5588  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5589  }
5590 
5592  inline int
5594  {
5595  return (int) (m_listCustom.size());
5596  }
5597 
5598  EResultCode
5600  addCustom (
5601  CParameter * pValue);
5602 
5603 
5604 };
5605 
5606 
5656 class CSET_READER_CONFIG : public CMessage
5657 {
5658  public:
5659  CSET_READER_CONFIG (void);
5660  ~CSET_READER_CONFIG (void);
5661 
5664 
5665  static const CFieldDescriptor * const
5666  s_apFieldDescriptorTable[];
5667 
5668  static const CTypeDescriptor
5669  s_typeDescriptor;
5670 
5671  void
5672  decodeFields (
5673  CDecoderStream * pDecoderStream);
5674 
5675  void
5676  assimilateSubParameters (
5677  CErrorDetails * pError);
5678 
5679  void
5680  encode (
5681  CEncoderStream * pEncoderStream) const;
5682 
5683 
5684 
5685  static CElement *
5686  s_construct (void);
5687 
5688  static void
5689  s_decodeFields (
5690  CDecoderStream * pDecoderStream,
5691  CElement * pElement);
5693 
5694 
5695  protected:
5696  llrp_u1_t m_ResetToFactoryDefault;
5697 
5700  public:
5701  static const CFieldDescriptor
5702  s_fdResetToFactoryDefault;
5704 
5706  inline llrp_u1_t
5708  {
5709  return m_ResetToFactoryDefault;
5710  }
5711 
5713  inline void
5715  llrp_u1_t value)
5716  {
5717  m_ResetToFactoryDefault = value;
5718  }
5719 
5720 
5721 
5722  protected:
5723  CReaderEventNotificationSpec * m_pReaderEventNotificationSpec;
5724 
5725  public:
5729  {
5730  return m_pReaderEventNotificationSpec;
5731  }
5732 
5734  EResultCode
5735  setReaderEventNotificationSpec (
5736  CReaderEventNotificationSpec * pValue);
5737 
5738 
5739  protected:
5740  std::list<CAntennaProperties *> m_listAntennaProperties;
5741 
5742  public:
5744  inline std::list<CAntennaProperties *>::iterator
5746  {
5747  return m_listAntennaProperties.begin();
5748  }
5749 
5751  inline std::list<CAntennaProperties *>::iterator
5753  {
5754  return m_listAntennaProperties.end();
5755  }
5756 
5758  inline void
5760  {
5761  clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties);
5762  }
5763 
5765  inline int
5767  {
5768  return (int) (m_listAntennaProperties.size());
5769  }
5770 
5771  EResultCode
5773  addAntennaProperties (
5774  CAntennaProperties * pValue);
5775 
5776 
5777  protected:
5778  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
5779 
5780  public:
5782  inline std::list<CAntennaConfiguration *>::iterator
5784  {
5785  return m_listAntennaConfiguration.begin();
5786  }
5787 
5789  inline std::list<CAntennaConfiguration *>::iterator
5791  {
5792  return m_listAntennaConfiguration.end();
5793  }
5794 
5796  inline void
5798  {
5799  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
5800  }
5801 
5803  inline int
5805  {
5806  return (int) (m_listAntennaConfiguration.size());
5807  }
5808 
5809  EResultCode
5811  addAntennaConfiguration (
5812  CAntennaConfiguration * pValue);
5813 
5814 
5815  protected:
5816  CROReportSpec * m_pROReportSpec;
5817 
5818  public:
5820  inline CROReportSpec *
5822  {
5823  return m_pROReportSpec;
5824  }
5825 
5827  EResultCode
5828  setROReportSpec (
5829  CROReportSpec * pValue);
5830 
5831 
5832  protected:
5833  CAccessReportSpec * m_pAccessReportSpec;
5834 
5835  public:
5837  inline CAccessReportSpec *
5839  {
5840  return m_pAccessReportSpec;
5841  }
5842 
5844  EResultCode
5845  setAccessReportSpec (
5846  CAccessReportSpec * pValue);
5847 
5848 
5849  protected:
5850  CKeepaliveSpec * m_pKeepaliveSpec;
5851 
5852  public:
5854  inline CKeepaliveSpec *
5856  {
5857  return m_pKeepaliveSpec;
5858  }
5859 
5861  EResultCode
5862  setKeepaliveSpec (
5863  CKeepaliveSpec * pValue);
5864 
5865 
5866  protected:
5867  std::list<CGPOWriteData *> m_listGPOWriteData;
5868 
5869  public:
5871  inline std::list<CGPOWriteData *>::iterator
5873  {
5874  return m_listGPOWriteData.begin();
5875  }
5876 
5878  inline std::list<CGPOWriteData *>::iterator
5880  {
5881  return m_listGPOWriteData.end();
5882  }
5883 
5885  inline void
5887  {
5888  clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData);
5889  }
5890 
5892  inline int
5894  {
5895  return (int) (m_listGPOWriteData.size());
5896  }
5897 
5898  EResultCode
5900  addGPOWriteData (
5901  CGPOWriteData * pValue);
5902 
5903 
5904  protected:
5905  std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState;
5906 
5907  public:
5909  inline std::list<CGPIPortCurrentState *>::iterator
5911  {
5912  return m_listGPIPortCurrentState.begin();
5913  }
5914 
5916  inline std::list<CGPIPortCurrentState *>::iterator
5918  {
5919  return m_listGPIPortCurrentState.end();
5920  }
5921 
5923  inline void
5925  {
5926  clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState);
5927  }
5928 
5930  inline int
5932  {
5933  return (int) (m_listGPIPortCurrentState.size());
5934  }
5935 
5936  EResultCode
5938  addGPIPortCurrentState (
5939  CGPIPortCurrentState * pValue);
5940 
5941 
5942  protected:
5943  CEventsAndReports * m_pEventsAndReports;
5944 
5945  public:
5947  inline CEventsAndReports *
5949  {
5950  return m_pEventsAndReports;
5951  }
5952 
5954  EResultCode
5955  setEventsAndReports (
5956  CEventsAndReports * pValue);
5957 
5958 
5959  protected:
5960  std::list<CParameter *> m_listCustom;
5961 
5962  public:
5964  inline std::list<CParameter *>::iterator
5966  {
5967  return m_listCustom.begin();
5968  }
5969 
5971  inline std::list<CParameter *>::iterator
5972  endCustom (void)
5973  {
5974  return m_listCustom.end();
5975  }
5976 
5978  inline void
5980  {
5981  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5982  }
5983 
5985  inline int
5987  {
5988  return (int) (m_listCustom.size());
5989  }
5990 
5991  EResultCode
5993  addCustom (
5994  CParameter * pValue);
5995 
5996 
5997 };
5998 
5999 
6030 class CSET_READER_CONFIG_RESPONSE : public CMessage
6031 {
6032  public:
6035 
6038 
6039  static const CFieldDescriptor * const
6040  s_apFieldDescriptorTable[];
6041 
6042  static const CTypeDescriptor
6043  s_typeDescriptor;
6044 
6045  void
6046  decodeFields (
6047  CDecoderStream * pDecoderStream);
6048 
6049  void
6050  assimilateSubParameters (
6051  CErrorDetails * pError);
6052 
6053  void
6054  encode (
6055  CEncoderStream * pEncoderStream) const;
6056 
6057 
6058 
6059  static CElement *
6060  s_construct (void);
6061 
6062  static void
6063  s_decodeFields (
6064  CDecoderStream * pDecoderStream,
6065  CElement * pElement);
6067 
6068 
6069 
6070  protected:
6071  CLLRPStatus * m_pLLRPStatus;
6072 
6073  public:
6075  inline CLLRPStatus *
6077  {
6078  return m_pLLRPStatus;
6079  }
6080 
6082  EResultCode
6083  setLLRPStatus (
6084  CLLRPStatus * pValue);
6085 
6086 
6087 };
6088 
6089 
6131 class CCLOSE_CONNECTION : public CMessage
6132 {
6133  public:
6134  CCLOSE_CONNECTION (void);
6135  ~CCLOSE_CONNECTION (void);
6136 
6139 
6140  static const CFieldDescriptor * const
6141  s_apFieldDescriptorTable[];
6142 
6143  static const CTypeDescriptor
6144  s_typeDescriptor;
6145 
6146  void
6147  decodeFields (
6148  CDecoderStream * pDecoderStream);
6149 
6150  void
6151  assimilateSubParameters (
6152  CErrorDetails * pError);
6153 
6154  void
6155  encode (
6156  CEncoderStream * pEncoderStream) const;
6157 
6158 
6159 
6160  static CElement *
6161  s_construct (void);
6162 
6163  static void
6164  s_decodeFields (
6165  CDecoderStream * pDecoderStream,
6166  CElement * pElement);
6168 
6169 
6170 
6171 };
6172 
6173 
6208 class CCLOSE_CONNECTION_RESPONSE : public CMessage
6209 {
6210  public:
6213 
6216 
6217  static const CFieldDescriptor * const
6218  s_apFieldDescriptorTable[];
6219 
6220  static const CTypeDescriptor
6221  s_typeDescriptor;
6222 
6223  void
6224  decodeFields (
6225  CDecoderStream * pDecoderStream);
6226 
6227  void
6228  assimilateSubParameters (
6229  CErrorDetails * pError);
6230 
6231  void
6232  encode (
6233  CEncoderStream * pEncoderStream) const;
6234 
6235 
6236 
6237  static CElement *
6238  s_construct (void);
6239 
6240  static void
6241  s_decodeFields (
6242  CDecoderStream * pDecoderStream,
6243  CElement * pElement);
6245 
6246 
6247 
6248  protected:
6249  CLLRPStatus * m_pLLRPStatus;
6250 
6251  public:
6253  inline CLLRPStatus *
6255  {
6256  return m_pLLRPStatus;
6257  }
6258 
6260  EResultCode
6261  setLLRPStatus (
6262  CLLRPStatus * pValue);
6263 
6264 
6265 };
6266 
6267 
6299 class CGET_REPORT : public CMessage
6300 {
6301  public:
6302  CGET_REPORT (void);
6303  ~CGET_REPORT (void);
6304 
6307 
6308  static const CFieldDescriptor * const
6309  s_apFieldDescriptorTable[];
6310 
6311  static const CTypeDescriptor
6312  s_typeDescriptor;
6313 
6314  void
6315  decodeFields (
6316  CDecoderStream * pDecoderStream);
6317 
6318  void
6319  assimilateSubParameters (
6320  CErrorDetails * pError);
6321 
6322  void
6323  encode (
6324  CEncoderStream * pEncoderStream) const;
6325 
6326 
6327 
6328  static CElement *
6329  s_construct (void);
6330 
6331  static void
6332  s_decodeFields (
6333  CDecoderStream * pDecoderStream,
6334  CElement * pElement);
6336 
6337 
6338 
6339 };
6340 
6341 
6374 class CRO_ACCESS_REPORT : public CMessage
6375 {
6376  public:
6377  CRO_ACCESS_REPORT (void);
6378  ~CRO_ACCESS_REPORT (void);
6379 
6382 
6383  static const CFieldDescriptor * const
6384  s_apFieldDescriptorTable[];
6385 
6386  static const CTypeDescriptor
6387  s_typeDescriptor;
6388 
6389  void
6390  decodeFields (
6391  CDecoderStream * pDecoderStream);
6392 
6393  void
6394  assimilateSubParameters (
6395  CErrorDetails * pError);
6396 
6397  void
6398  encode (
6399  CEncoderStream * pEncoderStream) const;
6400 
6401 
6402 
6403  static CElement *
6404  s_construct (void);
6405 
6406  static void
6407  s_decodeFields (
6408  CDecoderStream * pDecoderStream,
6409  CElement * pElement);
6411 
6412 
6413 
6414  protected:
6415  std::list<CTagReportData *> m_listTagReportData;
6416 
6417  public:
6419  inline std::list<CTagReportData *>::iterator
6421  {
6422  return m_listTagReportData.begin();
6423  }
6424 
6426  inline std::list<CTagReportData *>::iterator
6428  {
6429  return m_listTagReportData.end();
6430  }
6431 
6433  inline void
6435  {
6436  clearSubParameterList ((tListOfParameters *) &m_listTagReportData);
6437  }
6438 
6440  inline int
6442  {
6443  return (int) (m_listTagReportData.size());
6444  }
6445 
6446  EResultCode
6448  addTagReportData (
6449  CTagReportData * pValue);
6450 
6451 
6452  protected:
6453  std::list<CRFSurveyReportData *> m_listRFSurveyReportData;
6454 
6455  public:
6457  inline std::list<CRFSurveyReportData *>::iterator
6459  {
6460  return m_listRFSurveyReportData.begin();
6461  }
6462 
6464  inline std::list<CRFSurveyReportData *>::iterator
6466  {
6467  return m_listRFSurveyReportData.end();
6468  }
6469 
6471  inline void
6473  {
6474  clearSubParameterList ((tListOfParameters *) &m_listRFSurveyReportData);
6475  }
6476 
6478  inline int
6480  {
6481  return (int) (m_listRFSurveyReportData.size());
6482  }
6483 
6484  EResultCode
6486  addRFSurveyReportData (
6487  CRFSurveyReportData * pValue);
6488 
6489 
6490  protected:
6491  std::list<CParameter *> m_listCustom;
6492 
6493  public:
6495  inline std::list<CParameter *>::iterator
6497  {
6498  return m_listCustom.begin();
6499  }
6500 
6502  inline std::list<CParameter *>::iterator
6503  endCustom (void)
6504  {
6505  return m_listCustom.end();
6506  }
6507 
6509  inline void
6511  {
6512  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6513  }
6514 
6516  inline int
6518  {
6519  return (int) (m_listCustom.size());
6520  }
6521 
6522  EResultCode
6524  addCustom (
6525  CParameter * pValue);
6526 
6527 
6528 };
6529 
6530 
6560 class CKEEPALIVE : public CMessage
6561 {
6562  public:
6563  CKEEPALIVE (void);
6564  ~CKEEPALIVE (void);
6565 
6568 
6569  static const CFieldDescriptor * const
6570  s_apFieldDescriptorTable[];
6571 
6572  static const CTypeDescriptor
6573  s_typeDescriptor;
6574 
6575  void
6576  decodeFields (
6577  CDecoderStream * pDecoderStream);
6578 
6579  void
6580  assimilateSubParameters (
6581  CErrorDetails * pError);
6582 
6583  void
6584  encode (
6585  CEncoderStream * pEncoderStream) const;
6586 
6587 
6588 
6589  static CElement *
6590  s_construct (void);
6591 
6592  static void
6593  s_decodeFields (
6594  CDecoderStream * pDecoderStream,
6595  CElement * pElement);
6597 
6598 
6599 
6600 };
6601 
6602 
6634 class CKEEPALIVE_ACK : public CMessage
6635 {
6636  public:
6637  CKEEPALIVE_ACK (void);
6638  ~CKEEPALIVE_ACK (void);
6639 
6642 
6643  static const CFieldDescriptor * const
6644  s_apFieldDescriptorTable[];
6645 
6646  static const CTypeDescriptor
6647  s_typeDescriptor;
6648 
6649  void
6650  decodeFields (
6651  CDecoderStream * pDecoderStream);
6652 
6653  void
6654  assimilateSubParameters (
6655  CErrorDetails * pError);
6656 
6657  void
6658  encode (
6659  CEncoderStream * pEncoderStream) const;
6660 
6661 
6662 
6663  static CElement *
6664  s_construct (void);
6665 
6666  static void
6667  s_decodeFields (
6668  CDecoderStream * pDecoderStream,
6669  CElement * pElement);
6671 
6672 
6673 
6674 };
6675 
6676 
6707 class CREADER_EVENT_NOTIFICATION : public CMessage
6708 {
6709  public:
6712 
6715 
6716  static const CFieldDescriptor * const
6717  s_apFieldDescriptorTable[];
6718 
6719  static const CTypeDescriptor
6720  s_typeDescriptor;
6721 
6722  void
6723  decodeFields (
6724  CDecoderStream * pDecoderStream);
6725 
6726  void
6727  assimilateSubParameters (
6728  CErrorDetails * pError);
6729 
6730  void
6731  encode (
6732  CEncoderStream * pEncoderStream) const;
6733 
6734 
6735 
6736  static CElement *
6737  s_construct (void);
6738 
6739  static void
6740  s_decodeFields (
6741  CDecoderStream * pDecoderStream,
6742  CElement * pElement);
6744 
6745 
6746 
6747  protected:
6748  CReaderEventNotificationData * m_pReaderEventNotificationData;
6749 
6750  public:
6754  {
6755  return m_pReaderEventNotificationData;
6756  }
6757 
6759  EResultCode
6760  setReaderEventNotificationData (
6761  CReaderEventNotificationData * pValue);
6762 
6763 
6764 };
6765 
6766 
6796 class CENABLE_EVENTS_AND_REPORTS : public CMessage
6797 {
6798  public:
6801 
6804 
6805  static const CFieldDescriptor * const
6806  s_apFieldDescriptorTable[];
6807 
6808  static const CTypeDescriptor
6809  s_typeDescriptor;
6810 
6811  void
6812  decodeFields (
6813  CDecoderStream * pDecoderStream);
6814 
6815  void
6816  assimilateSubParameters (
6817  CErrorDetails * pError);
6818 
6819  void
6820  encode (
6821  CEncoderStream * pEncoderStream) const;
6822 
6823 
6824 
6825  static CElement *
6826  s_construct (void);
6827 
6828  static void
6829  s_decodeFields (
6830  CDecoderStream * pDecoderStream,
6831  CElement * pElement);
6833 
6834 
6835 
6836 };
6837 
6838 
6897 class CERROR_MESSAGE : public CMessage
6898 {
6899  public:
6900  CERROR_MESSAGE (void);
6901  ~CERROR_MESSAGE (void);
6902 
6905 
6906  static const CFieldDescriptor * const
6907  s_apFieldDescriptorTable[];
6908 
6909  static const CTypeDescriptor
6910  s_typeDescriptor;
6911 
6912  void
6913  decodeFields (
6914  CDecoderStream * pDecoderStream);
6915 
6916  void
6917  assimilateSubParameters (
6918  CErrorDetails * pError);
6919 
6920  void
6921  encode (
6922  CEncoderStream * pEncoderStream) const;
6923 
6924 
6925 
6926  static CElement *
6927  s_construct (void);
6928 
6929  static void
6930  s_decodeFields (
6931  CDecoderStream * pDecoderStream,
6932  CElement * pElement);
6934 
6935 
6936 
6937  protected:
6938  CLLRPStatus * m_pLLRPStatus;
6939 
6940  public:
6942  inline CLLRPStatus *
6944  {
6945  return m_pLLRPStatus;
6946  }
6947 
6949  EResultCode
6950  setLLRPStatus (
6951  CLLRPStatus * pValue);
6952 
6953 
6954 };
6955 
6956 
6964 
6999 class CUTCTimestamp : public CParameter
7000 {
7001  public:
7002  CUTCTimestamp (void);
7003  ~CUTCTimestamp (void);
7004 
7007 
7008  static const CFieldDescriptor * const
7009  s_apFieldDescriptorTable[];
7010 
7011  static const CTypeDescriptor
7012  s_typeDescriptor;
7013 
7014  void
7015  decodeFields (
7016  CDecoderStream * pDecoderStream);
7017 
7018  void
7019  assimilateSubParameters (
7020  CErrorDetails * pError);
7021 
7022  void
7023  encode (
7024  CEncoderStream * pEncoderStream) const;
7025 
7026 
7027 
7028  static CElement *
7029  s_construct (void);
7030 
7031  static void
7032  s_decodeFields (
7033  CDecoderStream * pDecoderStream,
7034  CElement * pElement);
7036 
7037 
7038  protected:
7039  llrp_u64_t m_Microseconds;
7040 
7043  public:
7044  static const CFieldDescriptor
7045  s_fdMicroseconds;
7047 
7049  inline llrp_u64_t
7051  {
7052  return m_Microseconds;
7053  }
7054 
7056  inline void
7058  llrp_u64_t value)
7059  {
7060  m_Microseconds = value;
7061  }
7062 
7063 
7064 
7065 };
7066 
7067 
7102 class CUptime : public CParameter
7103 {
7104  public:
7105  CUptime (void);
7106  ~CUptime (void);
7107 
7110 
7111  static const CFieldDescriptor * const
7112  s_apFieldDescriptorTable[];
7113 
7114  static const CTypeDescriptor
7115  s_typeDescriptor;
7116 
7117  void
7118  decodeFields (
7119  CDecoderStream * pDecoderStream);
7120 
7121  void
7122  assimilateSubParameters (
7123  CErrorDetails * pError);
7124 
7125  void
7126  encode (
7127  CEncoderStream * pEncoderStream) const;
7128 
7129 
7130 
7131  static CElement *
7132  s_construct (void);
7133 
7134  static void
7135  s_decodeFields (
7136  CDecoderStream * pDecoderStream,
7137  CElement * pElement);
7139 
7140 
7141  protected:
7142  llrp_u64_t m_Microseconds;
7143 
7146  public:
7147  static const CFieldDescriptor
7148  s_fdMicroseconds;
7150 
7152  inline llrp_u64_t
7154  {
7155  return m_Microseconds;
7156  }
7157 
7159  inline void
7161  llrp_u64_t value)
7162  {
7163  m_Microseconds = value;
7164  }
7165 
7166 
7167 
7168 };
7169 
7170 
7214 class CCustom : public CParameter
7215 {
7216  public:
7217  CCustom (void);
7218  ~CCustom (void);
7219 
7222 
7223  static const CFieldDescriptor * const
7224  s_apFieldDescriptorTable[];
7225 
7226  static const CTypeDescriptor
7227  s_typeDescriptor;
7228 
7229  void
7230  decodeFields (
7231  CDecoderStream * pDecoderStream);
7232 
7233  void
7234  assimilateSubParameters (
7235  CErrorDetails * pError);
7236 
7237  void
7238  encode (
7239  CEncoderStream * pEncoderStream) const;
7240 
7241 
7242 
7243  static CElement *
7244  s_construct (void);
7245 
7246  static void
7247  s_decodeFields (
7248  CDecoderStream * pDecoderStream,
7249  CElement * pElement);
7251 
7252 
7253  protected:
7254  llrp_u32_t m_VendorIdentifier;
7255 
7258  public:
7259  static const CFieldDescriptor
7260  s_fdVendorIdentifier;
7262 
7264  inline llrp_u32_t
7266  {
7267  return m_VendorIdentifier;
7268  }
7269 
7271  inline void
7273  llrp_u32_t value)
7274  {
7275  m_VendorIdentifier = value;
7276  }
7277 
7278 
7279  protected:
7280  llrp_u32_t m_ParameterSubtype;
7281 
7284  public:
7285  static const CFieldDescriptor
7286  s_fdParameterSubtype;
7288 
7290  inline llrp_u32_t
7292  {
7293  return m_ParameterSubtype;
7294  }
7295 
7297  inline void
7299  llrp_u32_t value)
7300  {
7301  m_ParameterSubtype = value;
7302  }
7303 
7304 
7305  protected:
7306  llrp_bytesToEnd_t m_Data;
7307 
7310  public:
7311  static const CFieldDescriptor
7312  s_fdData;
7314 
7316  inline llrp_bytesToEnd_t
7317  getData (void)
7318  {
7319  return m_Data;
7320  }
7321 
7323  inline void
7325  llrp_bytesToEnd_t value)
7326  {
7327  m_Data = value;
7328  }
7329 
7330 
7331 
7332 };
7333 
7334 
7375 class CGeneralDeviceCapabilities : public CParameter
7376 {
7377  public:
7380 
7383 
7384  static const CFieldDescriptor * const
7385  s_apFieldDescriptorTable[];
7386 
7387  static const CTypeDescriptor
7388  s_typeDescriptor;
7389 
7390  void
7391  decodeFields (
7392  CDecoderStream * pDecoderStream);
7393 
7394  void
7395  assimilateSubParameters (
7396  CErrorDetails * pError);
7397 
7398  void
7399  encode (
7400  CEncoderStream * pEncoderStream) const;
7401 
7402 
7403 
7404  static CElement *
7405  s_construct (void);
7406 
7407  static void
7408  s_decodeFields (
7409  CDecoderStream * pDecoderStream,
7410  CElement * pElement);
7412 
7413 
7414  protected:
7415  llrp_u16_t m_MaxNumberOfAntennaSupported;
7416 
7419  public:
7420  static const CFieldDescriptor
7421  s_fdMaxNumberOfAntennaSupported;
7423 
7425  inline llrp_u16_t
7427  {
7428  return m_MaxNumberOfAntennaSupported;
7429  }
7430 
7432  inline void
7434  llrp_u16_t value)
7435  {
7436  m_MaxNumberOfAntennaSupported = value;
7437  }
7438 
7439 
7440  protected:
7441  llrp_u1_t m_CanSetAntennaProperties;
7442 
7445  public:
7446  static const CFieldDescriptor
7447  s_fdCanSetAntennaProperties;
7449 
7451  inline llrp_u1_t
7453  {
7454  return m_CanSetAntennaProperties;
7455  }
7456 
7458  inline void
7460  llrp_u1_t value)
7461  {
7462  m_CanSetAntennaProperties = value;
7463  }
7464 
7465 
7466  protected:
7467  llrp_u1_t m_HasUTCClockCapability;
7468 
7471  public:
7472  static const CFieldDescriptor
7473  s_fdHasUTCClockCapability;
7475 
7477  inline llrp_u1_t
7479  {
7480  return m_HasUTCClockCapability;
7481  }
7482 
7484  inline void
7486  llrp_u1_t value)
7487  {
7488  m_HasUTCClockCapability = value;
7489  }
7490 
7491 
7492  protected:
7493  llrp_u32_t m_DeviceManufacturerName;
7494 
7497  public:
7498  static const CFieldDescriptor
7499  s_fdDeviceManufacturerName;
7501 
7503  inline llrp_u32_t
7505  {
7506  return m_DeviceManufacturerName;
7507  }
7508 
7510  inline void
7512  llrp_u32_t value)
7513  {
7514  m_DeviceManufacturerName = value;
7515  }
7516 
7517 
7518  protected:
7519  llrp_u32_t m_ModelName;
7520 
7523  public:
7524  static const CFieldDescriptor
7525  s_fdModelName;
7527 
7529  inline llrp_u32_t
7531  {
7532  return m_ModelName;
7533  }
7534 
7536  inline void
7538  llrp_u32_t value)
7539  {
7540  m_ModelName = value;
7541  }
7542 
7543 
7544  protected:
7545  llrp_utf8v_t m_ReaderFirmwareVersion;
7546 
7549  public:
7550  static const CFieldDescriptor
7551  s_fdReaderFirmwareVersion;
7553 
7555  inline llrp_utf8v_t
7557  {
7558  return m_ReaderFirmwareVersion;
7559  }
7560 
7562  inline void
7564  llrp_utf8v_t value)
7565  {
7566  m_ReaderFirmwareVersion = value;
7567  }
7568 
7569 
7570 
7571  protected:
7572  std::list<CReceiveSensitivityTableEntry *> m_listReceiveSensitivityTableEntry;
7573 
7574  public:
7576  inline std::list<CReceiveSensitivityTableEntry *>::iterator
7578  {
7579  return m_listReceiveSensitivityTableEntry.begin();
7580  }
7581 
7583  inline std::list<CReceiveSensitivityTableEntry *>::iterator
7585  {
7586  return m_listReceiveSensitivityTableEntry.end();
7587  }
7588 
7590  inline void
7592  {
7593  clearSubParameterList ((tListOfParameters *) &m_listReceiveSensitivityTableEntry);
7594  }
7595 
7597  inline int
7599  {
7600  return (int) (m_listReceiveSensitivityTableEntry.size());
7601  }
7602 
7603  EResultCode
7605  addReceiveSensitivityTableEntry (
7607 
7608 
7609  protected:
7610  std::list<CPerAntennaReceiveSensitivityRange *> m_listPerAntennaReceiveSensitivityRange;
7611 
7612  public:
7614  inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator
7616  {
7617  return m_listPerAntennaReceiveSensitivityRange.begin();
7618  }
7619 
7621  inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator
7623  {
7624  return m_listPerAntennaReceiveSensitivityRange.end();
7625  }
7626 
7628  inline void
7630  {
7631  clearSubParameterList ((tListOfParameters *) &m_listPerAntennaReceiveSensitivityRange);
7632  }
7633 
7635  inline int
7637  {
7638  return (int) (m_listPerAntennaReceiveSensitivityRange.size());
7639  }
7640 
7641  EResultCode
7643  addPerAntennaReceiveSensitivityRange (
7645 
7646 
7647  protected:
7648  CGPIOCapabilities * m_pGPIOCapabilities;
7649 
7650  public:
7652  inline CGPIOCapabilities *
7654  {
7655  return m_pGPIOCapabilities;
7656  }
7657 
7659  EResultCode
7660  setGPIOCapabilities (
7661  CGPIOCapabilities * pValue);
7662 
7663 
7664  protected:
7665  std::list<CPerAntennaAirProtocol *> m_listPerAntennaAirProtocol;
7666 
7667  public:
7669  inline std::list<CPerAntennaAirProtocol *>::iterator
7671  {
7672  return m_listPerAntennaAirProtocol.begin();
7673  }
7674 
7676  inline std::list<CPerAntennaAirProtocol *>::iterator
7678  {
7679  return m_listPerAntennaAirProtocol.end();
7680  }
7681 
7683  inline void
7685  {
7686  clearSubParameterList ((tListOfParameters *) &m_listPerAntennaAirProtocol);
7687  }
7688 
7690  inline int
7692  {
7693  return (int) (m_listPerAntennaAirProtocol.size());
7694  }
7695 
7696  EResultCode
7698  addPerAntennaAirProtocol (
7699  CPerAntennaAirProtocol * pValue);
7700 
7701 
7702 };
7703 
7704 
7739 class CReceiveSensitivityTableEntry : public CParameter
7740 {
7741  public:
7744 
7747 
7748  static const CFieldDescriptor * const
7749  s_apFieldDescriptorTable[];
7750 
7751  static const CTypeDescriptor
7752  s_typeDescriptor;
7753 
7754  void
7755  decodeFields (
7756  CDecoderStream * pDecoderStream);
7757 
7758  void
7759  assimilateSubParameters (
7760  CErrorDetails * pError);
7761 
7762  void
7763  encode (
7764  CEncoderStream * pEncoderStream) const;
7765 
7766 
7767 
7768  static CElement *
7769  s_construct (void);
7770 
7771  static void
7772  s_decodeFields (
7773  CDecoderStream * pDecoderStream,
7774  CElement * pElement);
7776 
7777 
7778  protected:
7779  llrp_u16_t m_Index;
7780 
7783  public:
7784  static const CFieldDescriptor
7785  s_fdIndex;
7787 
7789  inline llrp_u16_t
7790  getIndex (void)
7791  {
7792  return m_Index;
7793  }
7794 
7796  inline void
7798  llrp_u16_t value)
7799  {
7800  m_Index = value;
7801  }
7802 
7803 
7804  protected:
7805  llrp_s16_t m_ReceiveSensitivityValue;
7806 
7809  public:
7810  static const CFieldDescriptor
7811  s_fdReceiveSensitivityValue;
7813 
7815  inline llrp_s16_t
7817  {
7818  return m_ReceiveSensitivityValue;
7819  }
7820 
7822  inline void
7824  llrp_s16_t value)
7825  {
7826  m_ReceiveSensitivityValue = value;
7827  }
7828 
7829 
7830 
7831 };
7832 
7833 
7871 class CPerAntennaReceiveSensitivityRange : public CParameter
7872 {
7873  public:
7876 
7879 
7880  static const CFieldDescriptor * const
7881  s_apFieldDescriptorTable[];
7882 
7883  static const CTypeDescriptor
7884  s_typeDescriptor;
7885 
7886  void
7887  decodeFields (
7888  CDecoderStream * pDecoderStream);
7889 
7890  void
7891  assimilateSubParameters (
7892  CErrorDetails * pError);
7893 
7894  void
7895  encode (
7896  CEncoderStream * pEncoderStream) const;
7897 
7898 
7899 
7900  static CElement *
7901  s_construct (void);
7902 
7903  static void
7904  s_decodeFields (
7905  CDecoderStream * pDecoderStream,
7906  CElement * pElement);
7908 
7909 
7910  protected:
7911  llrp_u16_t m_AntennaID;
7912 
7915  public:
7916  static const CFieldDescriptor
7917  s_fdAntennaID;
7919 
7921  inline llrp_u16_t
7923  {
7924  return m_AntennaID;
7925  }
7926 
7928  inline void
7930  llrp_u16_t value)
7931  {
7932  m_AntennaID = value;
7933  }
7934 
7935 
7936  protected:
7937  llrp_u16_t m_ReceiveSensitivityIndexMin;
7938 
7941  public:
7942  static const CFieldDescriptor
7943  s_fdReceiveSensitivityIndexMin;
7945 
7947  inline llrp_u16_t
7949  {
7950  return m_ReceiveSensitivityIndexMin;
7951  }
7952 
7954  inline void
7956  llrp_u16_t value)
7957  {
7958  m_ReceiveSensitivityIndexMin = value;
7959  }
7960 
7961 
7962  protected:
7963  llrp_u16_t m_ReceiveSensitivityIndexMax;
7964 
7967  public:
7968  static const CFieldDescriptor
7969  s_fdReceiveSensitivityIndexMax;
7971 
7973  inline llrp_u16_t
7975  {
7976  return m_ReceiveSensitivityIndexMax;
7977  }
7978 
7980  inline void
7982  llrp_u16_t value)
7983  {
7984  m_ReceiveSensitivityIndexMax = value;
7985  }
7986 
7987 
7988 
7989 };
7990 
7991 
8023 class CPerAntennaAirProtocol : public CParameter
8024 {
8025  public:
8026  CPerAntennaAirProtocol (void);
8027  ~CPerAntennaAirProtocol (void);
8028 
8031 
8032  static const CFieldDescriptor * const
8033  s_apFieldDescriptorTable[];
8034 
8035  static const CTypeDescriptor
8036  s_typeDescriptor;
8037 
8038  void
8039  decodeFields (
8040  CDecoderStream * pDecoderStream);
8041 
8042  void
8043  assimilateSubParameters (
8044  CErrorDetails * pError);
8045 
8046  void
8047  encode (
8048  CEncoderStream * pEncoderStream) const;
8049 
8050 
8051 
8052  static CElement *
8053  s_construct (void);
8054 
8055  static void
8056  s_decodeFields (
8057  CDecoderStream * pDecoderStream,
8058  CElement * pElement);
8060 
8061 
8062  protected:
8063  llrp_u16_t m_AntennaID;
8064 
8067  public:
8068  static const CFieldDescriptor
8069  s_fdAntennaID;
8071 
8073  inline llrp_u16_t
8075  {
8076  return m_AntennaID;
8077  }
8078 
8080  inline void
8082  llrp_u16_t value)
8083  {
8084  m_AntennaID = value;
8085  }
8086 
8087 
8088  protected:
8089  llrp_u8v_t m_ProtocolID;
8090 
8093  public:
8094  static const CFieldDescriptor
8095  s_fdProtocolID;
8097 
8099  inline llrp_u8v_t
8101  {
8102  return m_ProtocolID;
8103  }
8104 
8106  inline void
8108  llrp_u8v_t value)
8109  {
8110  m_ProtocolID = value;
8111  }
8112 
8113 
8114 
8115 };
8116 
8117 
8149 class CGPIOCapabilities : public CParameter
8150 {
8151  public:
8152  CGPIOCapabilities (void);
8153  ~CGPIOCapabilities (void);
8154 
8157 
8158  static const CFieldDescriptor * const
8159  s_apFieldDescriptorTable[];
8160 
8161  static const CTypeDescriptor
8162  s_typeDescriptor;
8163 
8164  void
8165  decodeFields (
8166  CDecoderStream * pDecoderStream);
8167 
8168  void
8169  assimilateSubParameters (
8170  CErrorDetails * pError);
8171 
8172  void
8173  encode (
8174  CEncoderStream * pEncoderStream) const;
8175 
8176 
8177 
8178  static CElement *
8179  s_construct (void);
8180 
8181  static void
8182  s_decodeFields (
8183  CDecoderStream * pDecoderStream,
8184  CElement * pElement);
8186 
8187 
8188  protected:
8189  llrp_u16_t m_NumGPIs;
8190 
8193  public:
8194  static const CFieldDescriptor
8195  s_fdNumGPIs;
8197 
8199  inline llrp_u16_t
8200  getNumGPIs (void)
8201  {
8202  return m_NumGPIs;
8203  }
8204 
8206  inline void
8208  llrp_u16_t value)
8209  {
8210  m_NumGPIs = value;
8211  }
8212 
8213 
8214  protected:
8215  llrp_u16_t m_NumGPOs;
8216 
8219  public:
8220  static const CFieldDescriptor
8221  s_fdNumGPOs;
8223 
8225  inline llrp_u16_t
8226  getNumGPOs (void)
8227  {
8228  return m_NumGPOs;
8229  }
8230 
8232  inline void
8234  llrp_u16_t value)
8235  {
8236  m_NumGPOs = value;
8237  }
8238 
8239 
8240 
8241 };
8242 
8243 
8303 class CLLRPCapabilities : public CParameter
8304 {
8305  public:
8306  CLLRPCapabilities (void);
8307  ~CLLRPCapabilities (void);
8308 
8311 
8312  static const CFieldDescriptor * const
8313  s_apFieldDescriptorTable[];
8314 
8315  static const CTypeDescriptor
8316  s_typeDescriptor;
8317 
8318  void
8319  decodeFields (
8320  CDecoderStream * pDecoderStream);
8321 
8322  void
8323  assimilateSubParameters (
8324  CErrorDetails * pError);
8325 
8326  void
8327  encode (
8328  CEncoderStream * pEncoderStream) const;
8329 
8330 
8331 
8332  static CElement *
8333  s_construct (void);
8334 
8335  static void
8336  s_decodeFields (
8337  CDecoderStream * pDecoderStream,
8338  CElement * pElement);
8340 
8341 
8342  protected:
8343  llrp_u1_t m_CanDoRFSurvey;
8344 
8347  public:
8348  static const CFieldDescriptor
8349  s_fdCanDoRFSurvey;
8351 
8353  inline llrp_u1_t
8355  {
8356  return m_CanDoRFSurvey;
8357  }
8358 
8360  inline void
8362  llrp_u1_t value)
8363  {
8364  m_CanDoRFSurvey = value;
8365  }
8366 
8367 
8368  protected:
8369  llrp_u1_t m_CanReportBufferFillWarning;
8370 
8373  public:
8374  static const CFieldDescriptor
8375  s_fdCanReportBufferFillWarning;
8377 
8379  inline llrp_u1_t
8381  {
8382  return m_CanReportBufferFillWarning;
8383  }
8384 
8386  inline void
8388  llrp_u1_t value)
8389  {
8390  m_CanReportBufferFillWarning = value;
8391  }
8392 
8393 
8394  protected:
8395  llrp_u1_t m_SupportsClientRequestOpSpec;
8396 
8399  public:
8400  static const CFieldDescriptor
8401  s_fdSupportsClientRequestOpSpec;
8403 
8405  inline llrp_u1_t
8407  {
8408  return m_SupportsClientRequestOpSpec;
8409  }
8410 
8412  inline void
8414  llrp_u1_t value)
8415  {
8416  m_SupportsClientRequestOpSpec = value;
8417  }
8418 
8419 
8420  protected:
8421  llrp_u1_t m_CanDoTagInventoryStateAwareSingulation;
8422 
8425  public:
8426  static const CFieldDescriptor
8427  s_fdCanDoTagInventoryStateAwareSingulation;
8429 
8431  inline llrp_u1_t
8433  {
8434  return m_CanDoTagInventoryStateAwareSingulation;
8435  }
8436 
8438  inline void
8440  llrp_u1_t value)
8441  {
8442  m_CanDoTagInventoryStateAwareSingulation = value;
8443  }
8444 
8445 
8446  protected:
8447  llrp_u1_t m_SupportsEventAndReportHolding;
8448 
8451  public:
8452  static const CFieldDescriptor
8453  s_fdSupportsEventAndReportHolding;
8455 
8457  inline llrp_u1_t
8459  {
8460  return m_SupportsEventAndReportHolding;
8461  }
8462 
8464  inline void
8466  llrp_u1_t value)
8467  {
8468  m_SupportsEventAndReportHolding = value;
8469  }
8470 
8471 
8472  protected:
8473  llrp_u8_t m_MaxNumPriorityLevelsSupported;
8474 
8477  public:
8478  static const CFieldDescriptor
8479  s_fdMaxNumPriorityLevelsSupported;
8481 
8483  inline llrp_u8_t
8485  {
8486  return m_MaxNumPriorityLevelsSupported;
8487  }
8488 
8490  inline void
8492  llrp_u8_t value)
8493  {
8494  m_MaxNumPriorityLevelsSupported = value;
8495  }
8496 
8497 
8498  protected:
8499  llrp_u16_t m_ClientRequestOpSpecTimeout;
8500 
8503  public:
8504  static const CFieldDescriptor
8505  s_fdClientRequestOpSpecTimeout;
8507 
8509  inline llrp_u16_t
8511  {
8512  return m_ClientRequestOpSpecTimeout;
8513  }
8514 
8516  inline void
8518  llrp_u16_t value)
8519  {
8520  m_ClientRequestOpSpecTimeout = value;
8521  }
8522 
8523 
8524  protected:
8525  llrp_u32_t m_MaxNumROSpecs;
8526 
8529  public:
8530  static const CFieldDescriptor
8531  s_fdMaxNumROSpecs;
8533 
8535  inline llrp_u32_t
8537  {
8538  return m_MaxNumROSpecs;
8539  }
8540 
8542  inline void
8544  llrp_u32_t value)
8545  {
8546  m_MaxNumROSpecs = value;
8547  }
8548 
8549 
8550  protected:
8551  llrp_u32_t m_MaxNumSpecsPerROSpec;
8552 
8555  public:
8556  static const CFieldDescriptor
8557  s_fdMaxNumSpecsPerROSpec;
8559 
8561  inline llrp_u32_t
8563  {
8564  return m_MaxNumSpecsPerROSpec;
8565  }
8566 
8568  inline void
8570  llrp_u32_t value)
8571  {
8572  m_MaxNumSpecsPerROSpec = value;
8573  }
8574 
8575 
8576  protected:
8577  llrp_u32_t m_MaxNumInventoryParameterSpecsPerAISpec;
8578 
8581  public:
8582  static const CFieldDescriptor
8583  s_fdMaxNumInventoryParameterSpecsPerAISpec;
8585 
8587  inline llrp_u32_t
8589  {
8590  return m_MaxNumInventoryParameterSpecsPerAISpec;
8591  }
8592 
8594  inline void
8596  llrp_u32_t value)
8597  {
8598  m_MaxNumInventoryParameterSpecsPerAISpec = value;
8599  }
8600 
8601 
8602  protected:
8603  llrp_u32_t m_MaxNumAccessSpecs;
8604 
8607  public:
8608  static const CFieldDescriptor
8609  s_fdMaxNumAccessSpecs;
8611 
8613  inline llrp_u32_t
8615  {
8616  return m_MaxNumAccessSpecs;
8617  }
8618 
8620  inline void
8622  llrp_u32_t value)
8623  {
8624  m_MaxNumAccessSpecs = value;
8625  }
8626 
8627 
8628  protected:
8629  llrp_u32_t m_MaxNumOpSpecsPerAccessSpec;
8630 
8633  public:
8634  static const CFieldDescriptor
8635  s_fdMaxNumOpSpecsPerAccessSpec;
8637 
8639  inline llrp_u32_t
8641  {
8642  return m_MaxNumOpSpecsPerAccessSpec;
8643  }
8644 
8646  inline void
8648  llrp_u32_t value)
8649  {
8650  m_MaxNumOpSpecsPerAccessSpec = value;
8651  }
8652 
8653 
8654 
8655 };
8656 
8657 
8694 class CRegulatoryCapabilities : public CParameter
8695 {
8696  public:
8697  CRegulatoryCapabilities (void);
8698  ~CRegulatoryCapabilities (void);
8699 
8702 
8703  static const CFieldDescriptor * const
8704  s_apFieldDescriptorTable[];
8705 
8706  static const CTypeDescriptor
8707  s_typeDescriptor;
8708 
8709  void
8710  decodeFields (
8711  CDecoderStream * pDecoderStream);
8712 
8713  void
8714  assimilateSubParameters (
8715  CErrorDetails * pError);
8716 
8717  void
8718  encode (
8719  CEncoderStream * pEncoderStream) const;
8720 
8721 
8722 
8723  static CElement *
8724  s_construct (void);
8725 
8726  static void
8727  s_decodeFields (
8728  CDecoderStream * pDecoderStream,
8729  CElement * pElement);
8731 
8732 
8733  protected:
8734  llrp_u16_t m_CountryCode;
8735 
8738  public:
8739  static const CFieldDescriptor
8740  s_fdCountryCode;
8742 
8744  inline llrp_u16_t
8746  {
8747  return m_CountryCode;
8748  }
8749 
8751  inline void
8753  llrp_u16_t value)
8754  {
8755  m_CountryCode = value;
8756  }
8757 
8758 
8759  protected:
8760  ECommunicationsStandard m_eCommunicationsStandard;
8761 
8764  public:
8765  static const CFieldDescriptor
8766  s_fdCommunicationsStandard;
8768 
8770  inline ECommunicationsStandard
8772  {
8773  return m_eCommunicationsStandard;
8774  }
8775 
8777  inline void
8779  ECommunicationsStandard value)
8780  {
8781  m_eCommunicationsStandard = value;
8782  }
8783 
8784 
8785 
8786  protected:
8787  CUHFBandCapabilities * m_pUHFBandCapabilities;
8788 
8789  public:
8791  inline CUHFBandCapabilities *
8793  {
8794  return m_pUHFBandCapabilities;
8795  }
8796 
8798  EResultCode
8799  setUHFBandCapabilities (
8800  CUHFBandCapabilities * pValue);
8801 
8802 
8803  protected:
8804  std::list<CParameter *> m_listCustom;
8805 
8806  public:
8808  inline std::list<CParameter *>::iterator
8810  {
8811  return m_listCustom.begin();
8812  }
8813 
8815  inline std::list<CParameter *>::iterator
8816  endCustom (void)
8817  {
8818  return m_listCustom.end();
8819  }
8820 
8822  inline void
8824  {
8825  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8826  }
8827 
8829  inline int
8831  {
8832  return (int) (m_listCustom.size());
8833  }
8834 
8835  EResultCode
8837  addCustom (
8838  CParameter * pValue);
8839 
8840 
8841 };
8842 
8843 
8876 class CUHFBandCapabilities : public CParameter
8877 {
8878  public:
8879  CUHFBandCapabilities (void);
8880  ~CUHFBandCapabilities (void);
8881 
8884 
8885  static const CFieldDescriptor * const
8886  s_apFieldDescriptorTable[];
8887 
8888  static const CTypeDescriptor
8889  s_typeDescriptor;
8890 
8891  void
8892  decodeFields (
8893  CDecoderStream * pDecoderStream);
8894 
8895  void
8896  assimilateSubParameters (
8897  CErrorDetails * pError);
8898 
8899  void
8900  encode (
8901  CEncoderStream * pEncoderStream) const;
8902 
8903 
8904 
8905  static CElement *
8906  s_construct (void);
8907 
8908  static void
8909  s_decodeFields (
8910  CDecoderStream * pDecoderStream,
8911  CElement * pElement);
8913 
8914 
8915 
8916  protected:
8917  std::list<CTransmitPowerLevelTableEntry *> m_listTransmitPowerLevelTableEntry;
8918 
8919  public:
8921  inline std::list<CTransmitPowerLevelTableEntry *>::iterator
8923  {
8924  return m_listTransmitPowerLevelTableEntry.begin();
8925  }
8926 
8928  inline std::list<CTransmitPowerLevelTableEntry *>::iterator
8930  {
8931  return m_listTransmitPowerLevelTableEntry.end();
8932  }
8933 
8935  inline void
8937  {
8938  clearSubParameterList ((tListOfParameters *) &m_listTransmitPowerLevelTableEntry);
8939  }
8940 
8942  inline int
8944  {
8945  return (int) (m_listTransmitPowerLevelTableEntry.size());
8946  }
8947 
8948  EResultCode
8950  addTransmitPowerLevelTableEntry (
8952 
8953 
8954  protected:
8955  CFrequencyInformation * m_pFrequencyInformation;
8956 
8957  public:
8959  inline CFrequencyInformation *
8961  {
8962  return m_pFrequencyInformation;
8963  }
8964 
8966  EResultCode
8967  setFrequencyInformation (
8968  CFrequencyInformation * pValue);
8969 
8970 
8971  protected:
8972  std::list<CParameter *> m_listAirProtocolUHFRFModeTable;
8973 
8974  public:
8976  inline std::list<CParameter *>::iterator
8978  {
8979  return m_listAirProtocolUHFRFModeTable.begin();
8980  }
8981 
8983  inline std::list<CParameter *>::iterator
8985  {
8986  return m_listAirProtocolUHFRFModeTable.end();
8987  }
8988 
8990  inline void
8992  {
8993  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolUHFRFModeTable);
8994  }
8995 
8997  inline int
8999  {
9000  return (int) (m_listAirProtocolUHFRFModeTable.size());
9001  }
9002 
9003  EResultCode
9005  addAirProtocolUHFRFModeTable (
9006  CParameter * pValue);
9007 
9008 
9009 };
9010 
9011 
9043 class CTransmitPowerLevelTableEntry : public CParameter
9044 {
9045  public:
9048 
9051 
9052  static const CFieldDescriptor * const
9053  s_apFieldDescriptorTable[];
9054 
9055  static const CTypeDescriptor
9056  s_typeDescriptor;
9057 
9058  void
9059  decodeFields (
9060  CDecoderStream * pDecoderStream);
9061 
9062  void
9063  assimilateSubParameters (
9064  CErrorDetails * pError);
9065 
9066  void
9067  encode (
9068  CEncoderStream * pEncoderStream) const;
9069 
9070 
9071 
9072  static CElement *
9073  s_construct (void);
9074 
9075  static void
9076  s_decodeFields (
9077  CDecoderStream * pDecoderStream,
9078  CElement * pElement);
9080 
9081 
9082  protected:
9083  llrp_u16_t m_Index;
9084 
9087  public:
9088  static const CFieldDescriptor
9089  s_fdIndex;
9091 
9093  inline llrp_u16_t
9094  getIndex (void)
9095  {
9096  return m_Index;
9097  }
9098 
9100  inline void
9102  llrp_u16_t value)
9103  {
9104  m_Index = value;
9105  }
9106 
9107 
9108  protected:
9109  llrp_s16_t m_TransmitPowerValue;
9110 
9113  public:
9114  static const CFieldDescriptor
9115  s_fdTransmitPowerValue;
9117 
9119  inline llrp_s16_t
9121  {
9122  return m_TransmitPowerValue;
9123  }
9124 
9126  inline void
9128  llrp_s16_t value)
9129  {
9130  m_TransmitPowerValue = value;
9131  }
9132 
9133 
9134 
9135 };
9136 
9137 
9171 class CFrequencyInformation : public CParameter
9172 {
9173  public:
9174  CFrequencyInformation (void);
9175  ~CFrequencyInformation (void);
9176 
9179 
9180  static const CFieldDescriptor * const
9181  s_apFieldDescriptorTable[];
9182 
9183  static const CTypeDescriptor
9184  s_typeDescriptor;
9185 
9186  void
9187  decodeFields (
9188  CDecoderStream * pDecoderStream);
9189 
9190  void
9191  assimilateSubParameters (
9192  CErrorDetails * pError);
9193 
9194  void
9195  encode (
9196  CEncoderStream * pEncoderStream) const;
9197 
9198 
9199 
9200  static CElement *
9201  s_construct (void);
9202 
9203  static void
9204  s_decodeFields (
9205  CDecoderStream * pDecoderStream,
9206  CElement * pElement);
9208 
9209 
9210  protected:
9211  llrp_u1_t m_Hopping;
9212 
9215  public:
9216  static const CFieldDescriptor
9217  s_fdHopping;
9219 
9221  inline llrp_u1_t
9222  getHopping (void)
9223  {
9224  return m_Hopping;
9225  }
9226 
9228  inline void
9230  llrp_u1_t value)
9231  {
9232  m_Hopping = value;
9233  }
9234 
9235 
9236 
9237  protected:
9238  std::list<CFrequencyHopTable *> m_listFrequencyHopTable;
9239 
9240  public:
9242  inline std::list<CFrequencyHopTable *>::iterator
9244  {
9245  return m_listFrequencyHopTable.begin();
9246  }
9247 
9249  inline std::list<CFrequencyHopTable *>::iterator
9251  {
9252  return m_listFrequencyHopTable.end();
9253  }
9254 
9256  inline void
9258  {
9259  clearSubParameterList ((tListOfParameters *) &m_listFrequencyHopTable);
9260  }
9261 
9263  inline int
9265  {
9266  return (int) (m_listFrequencyHopTable.size());
9267  }
9268 
9269  EResultCode
9271  addFrequencyHopTable (
9272  CFrequencyHopTable * pValue);
9273 
9274 
9275  protected:
9276  CFixedFrequencyTable * m_pFixedFrequencyTable;
9277 
9278  public:
9280  inline CFixedFrequencyTable *
9282  {
9283  return m_pFixedFrequencyTable;
9284  }
9285 
9287  EResultCode
9288  setFixedFrequencyTable (
9289  CFixedFrequencyTable * pValue);
9290 
9291 
9292 };
9293 
9294 
9341 class CFrequencyHopTable : public CParameter
9342 {
9343  public:
9344  CFrequencyHopTable (void);
9345  ~CFrequencyHopTable (void);
9346 
9349 
9350  static const CFieldDescriptor * const
9351  s_apFieldDescriptorTable[];
9352 
9353  static const CTypeDescriptor
9354  s_typeDescriptor;
9355 
9356  void
9357  decodeFields (
9358  CDecoderStream * pDecoderStream);
9359 
9360  void
9361  assimilateSubParameters (
9362  CErrorDetails * pError);
9363 
9364  void
9365  encode (
9366  CEncoderStream * pEncoderStream) const;
9367 
9368 
9369 
9370  static CElement *
9371  s_construct (void);
9372 
9373  static void
9374  s_decodeFields (
9375  CDecoderStream * pDecoderStream,
9376  CElement * pElement);
9378 
9379 
9380  protected:
9381  llrp_u8_t m_HopTableID;
9382 
9385  public:
9386  static const CFieldDescriptor
9387  s_fdHopTableID;
9389 
9391  inline llrp_u8_t
9393  {
9394  return m_HopTableID;
9395  }
9396 
9398  inline void
9400  llrp_u8_t value)
9401  {
9402  m_HopTableID = value;
9403  }
9404 
9405 
9406  protected:
9407  llrp_u32v_t m_Frequency;
9408 
9411  public:
9412  static const CFieldDescriptor
9413  s_fdFrequency;
9415 
9417  inline llrp_u32v_t
9419  {
9420  return m_Frequency;
9421  }
9422 
9424  inline void
9426  llrp_u32v_t value)
9427  {
9428  m_Frequency = value;
9429  }
9430 
9431 
9432 
9433 };
9434 
9435 
9466 class CFixedFrequencyTable : public CParameter
9467 {
9468  public:
9469  CFixedFrequencyTable (void);
9470  ~CFixedFrequencyTable (void);
9471 
9474 
9475  static const CFieldDescriptor * const
9476  s_apFieldDescriptorTable[];
9477 
9478  static const CTypeDescriptor
9479  s_typeDescriptor;
9480 
9481  void
9482  decodeFields (
9483  CDecoderStream * pDecoderStream);
9484 
9485  void
9486  assimilateSubParameters (
9487  CErrorDetails * pError);
9488 
9489  void
9490  encode (
9491  CEncoderStream * pEncoderStream) const;
9492 
9493 
9494 
9495  static CElement *
9496  s_construct (void);
9497 
9498  static void
9499  s_decodeFields (
9500  CDecoderStream * pDecoderStream,
9501  CElement * pElement);
9503 
9504 
9505  protected:
9506  llrp_u32v_t m_Frequency;
9507 
9510  public:
9511  static const CFieldDescriptor
9512  s_fdFrequency;
9514 
9516  inline llrp_u32v_t
9518  {
9519  return m_Frequency;
9520  }
9521 
9523  inline void
9525  llrp_u32v_t value)
9526  {
9527  m_Frequency = value;
9528  }
9529 
9530 
9531 
9532 };
9533 
9534 
9570 class CROSpec : public CParameter
9571 {
9572  public:
9573  CROSpec (void);
9574  ~CROSpec (void);
9575 
9578 
9579  static const CFieldDescriptor * const
9580  s_apFieldDescriptorTable[];
9581 
9582  static const CTypeDescriptor
9583  s_typeDescriptor;
9584 
9585  void
9586  decodeFields (
9587  CDecoderStream * pDecoderStream);
9588 
9589  void
9590  assimilateSubParameters (
9591  CErrorDetails * pError);
9592 
9593  void
9594  encode (
9595  CEncoderStream * pEncoderStream) const;
9596 
9597 
9598 
9599  static CElement *
9600  s_construct (void);
9601 
9602  static void
9603  s_decodeFields (
9604  CDecoderStream * pDecoderStream,
9605  CElement * pElement);
9607 
9608 
9609  protected:
9610  llrp_u32_t m_ROSpecID;
9611 
9614  public:
9615  static const CFieldDescriptor
9616  s_fdROSpecID;
9618 
9620  inline llrp_u32_t
9622  {
9623  return m_ROSpecID;
9624  }
9625 
9627  inline void
9629  llrp_u32_t value)
9630  {
9631  m_ROSpecID = value;
9632  }
9633 
9634 
9635  protected:
9636  llrp_u8_t m_Priority;
9637 
9640  public:
9641  static const CFieldDescriptor
9642  s_fdPriority;
9644 
9646  inline llrp_u8_t
9648  {
9649  return m_Priority;
9650  }
9651 
9653  inline void
9655  llrp_u8_t value)
9656  {
9657  m_Priority = value;
9658  }
9659 
9660 
9661  protected:
9662  EROSpecState m_eCurrentState;
9663 
9666  public:
9667  static const CFieldDescriptor
9668  s_fdCurrentState;
9670 
9672  inline EROSpecState
9674  {
9675  return m_eCurrentState;
9676  }
9677 
9679  inline void
9681  EROSpecState value)
9682  {
9683  m_eCurrentState = value;
9684  }
9685 
9686 
9687 
9688  protected:
9689  CROBoundarySpec * m_pROBoundarySpec;
9690 
9691  public:
9693  inline CROBoundarySpec *
9695  {
9696  return m_pROBoundarySpec;
9697  }
9698 
9700  EResultCode
9701  setROBoundarySpec (
9702  CROBoundarySpec * pValue);
9703 
9704 
9705  protected:
9706  std::list<CParameter *> m_listSpecParameter;
9707 
9708  public:
9710  inline std::list<CParameter *>::iterator
9712  {
9713  return m_listSpecParameter.begin();
9714  }
9715 
9717  inline std::list<CParameter *>::iterator
9719  {
9720  return m_listSpecParameter.end();
9721  }
9722 
9724  inline void
9726  {
9727  clearSubParameterList ((tListOfParameters *) &m_listSpecParameter);
9728  }
9729 
9731  inline int
9733  {
9734  return (int) (m_listSpecParameter.size());
9735  }
9736 
9737  EResultCode
9739  addSpecParameter (
9740  CParameter * pValue);
9741 
9742 
9743  protected:
9744  CROReportSpec * m_pROReportSpec;
9745 
9746  public:
9748  inline CROReportSpec *
9750  {
9751  return m_pROReportSpec;
9752  }
9753 
9755  EResultCode
9756  setROReportSpec (
9757  CROReportSpec * pValue);
9758 
9759 
9760 };
9761 
9762 
9794 class CROBoundarySpec : public CParameter
9795 {
9796  public:
9797  CROBoundarySpec (void);
9798  ~CROBoundarySpec (void);
9799 
9802 
9803  static const CFieldDescriptor * const
9804  s_apFieldDescriptorTable[];
9805 
9806  static const CTypeDescriptor
9807  s_typeDescriptor;
9808 
9809  void
9810  decodeFields (
9811  CDecoderStream * pDecoderStream);
9812 
9813  void
9814  assimilateSubParameters (
9815  CErrorDetails * pError);
9816 
9817  void
9818  encode (
9819  CEncoderStream * pEncoderStream) const;
9820 
9821 
9822 
9823  static CElement *
9824  s_construct (void);
9825 
9826  static void
9827  s_decodeFields (
9828  CDecoderStream * pDecoderStream,
9829  CElement * pElement);
9831 
9832 
9833 
9834  protected:
9835  CROSpecStartTrigger * m_pROSpecStartTrigger;
9836 
9837  public:
9839  inline CROSpecStartTrigger *
9841  {
9842  return m_pROSpecStartTrigger;
9843  }
9844 
9846  EResultCode
9847  setROSpecStartTrigger (
9848  CROSpecStartTrigger * pValue);
9849 
9850 
9851  protected:
9852  CROSpecStopTrigger * m_pROSpecStopTrigger;
9853 
9854  public:
9856  inline CROSpecStopTrigger *
9858  {
9859  return m_pROSpecStopTrigger;
9860  }
9861 
9863  EResultCode
9864  setROSpecStopTrigger (
9865  CROSpecStopTrigger * pValue);
9866 
9867 
9868 };
9869 
9870 
9903 class CROSpecStartTrigger : public CParameter
9904 {
9905  public:
9906  CROSpecStartTrigger (void);
9907  ~CROSpecStartTrigger (void);
9908 
9911 
9912  static const CFieldDescriptor * const
9913  s_apFieldDescriptorTable[];
9914 
9915  static const CTypeDescriptor
9916  s_typeDescriptor;
9917 
9918  void
9919  decodeFields (
9920  CDecoderStream * pDecoderStream);
9921 
9922  void
9923  assimilateSubParameters (
9924  CErrorDetails * pError);
9925 
9926  void
9927  encode (
9928  CEncoderStream * pEncoderStream) const;
9929 
9930 
9931 
9932  static CElement *
9933  s_construct (void);
9934 
9935  static void
9936  s_decodeFields (
9937  CDecoderStream * pDecoderStream,
9938  CElement * pElement);
9940 
9941 
9942  protected:
9943  EROSpecStartTriggerType m_eROSpecStartTriggerType;
9944 
9947  public:
9948  static const CFieldDescriptor
9949  s_fdROSpecStartTriggerType;
9951 
9953  inline EROSpecStartTriggerType
9955  {
9956  return m_eROSpecStartTriggerType;
9957  }
9958 
9960  inline void
9962  EROSpecStartTriggerType value)
9963  {
9964  m_eROSpecStartTriggerType = value;
9965  }
9966 
9967 
9968 
9969  protected:
9970  CPeriodicTriggerValue * m_pPeriodicTriggerValue;
9971 
9972  public:
9974  inline CPeriodicTriggerValue *
9976  {
9977  return m_pPeriodicTriggerValue;
9978  }
9979 
9981  EResultCode
9982  setPeriodicTriggerValue (
9983  CPeriodicTriggerValue * pValue);
9984 
9985 
9986  protected:
9987  CGPITriggerValue * m_pGPITriggerValue;
9988 
9989  public:
9991  inline CGPITriggerValue *
9993  {
9994  return m_pGPITriggerValue;
9995  }
9996 
9998  EResultCode
9999  setGPITriggerValue (
10000  CGPITriggerValue * pValue);
10001 
10002 
10003 };
10004 
10005 
10049 class CPeriodicTriggerValue : public CParameter
10050 {
10051  public:
10052  CPeriodicTriggerValue (void);
10053  ~CPeriodicTriggerValue (void);
10054 
10057 
10058  static const CFieldDescriptor * const
10059  s_apFieldDescriptorTable[];
10060 
10061  static const CTypeDescriptor
10062  s_typeDescriptor;
10063 
10064  void
10065  decodeFields (
10066  CDecoderStream * pDecoderStream);
10067 
10068  void
10069  assimilateSubParameters (
10070  CErrorDetails * pError);
10071 
10072  void
10073  encode (
10074  CEncoderStream * pEncoderStream) const;
10075 
10076 
10077 
10078  static CElement *
10079  s_construct (void);
10080 
10081  static void
10082  s_decodeFields (
10083  CDecoderStream * pDecoderStream,
10084  CElement * pElement);
10086 
10087 
10088  protected:
10089  llrp_u32_t m_Offset;
10090 
10093  public:
10094  static const CFieldDescriptor
10095  s_fdOffset;
10097 
10099  inline llrp_u32_t
10100  getOffset (void)
10101  {
10102  return m_Offset;
10103  }
10104 
10106  inline void
10108  llrp_u32_t value)
10109  {
10110  m_Offset = value;
10111  }
10112 
10113 
10114  protected:
10115  llrp_u32_t m_Period;
10116 
10119  public:
10120  static const CFieldDescriptor
10121  s_fdPeriod;
10123 
10125  inline llrp_u32_t
10126  getPeriod (void)
10127  {
10128  return m_Period;
10129  }
10130 
10132  inline void
10134  llrp_u32_t value)
10135  {
10136  m_Period = value;
10137  }
10138 
10139 
10140 
10141  protected:
10142  CUTCTimestamp * m_pUTCTimestamp;
10143 
10144  public:
10146  inline CUTCTimestamp *
10148  {
10149  return m_pUTCTimestamp;
10150  }
10151 
10153  EResultCode
10154  setUTCTimestamp (
10155  CUTCTimestamp * pValue);
10156 
10157 
10158 };
10159 
10160 
10206 class CGPITriggerValue : public CParameter
10207 {
10208  public:
10209  CGPITriggerValue (void);
10210  ~CGPITriggerValue (void);
10211 
10214 
10215  static const CFieldDescriptor * const
10216  s_apFieldDescriptorTable[];
10217 
10218  static const CTypeDescriptor
10219  s_typeDescriptor;
10220 
10221  void
10222  decodeFields (
10223  CDecoderStream * pDecoderStream);
10224 
10225  void
10226  assimilateSubParameters (
10227  CErrorDetails * pError);
10228 
10229  void
10230  encode (
10231  CEncoderStream * pEncoderStream) const;
10232 
10233 
10234 
10235  static CElement *
10236  s_construct (void);
10237 
10238  static void
10239  s_decodeFields (
10240  CDecoderStream * pDecoderStream,
10241  CElement * pElement);
10243 
10244 
10245  protected:
10246  llrp_u16_t m_GPIPortNum;
10247 
10250  public:
10251  static const CFieldDescriptor
10252  s_fdGPIPortNum;
10254 
10256  inline llrp_u16_t
10258  {
10259  return m_GPIPortNum;
10260  }
10261 
10263  inline void
10265  llrp_u16_t value)
10266  {
10267  m_GPIPortNum = value;
10268  }
10269 
10270 
10271  protected:
10272  llrp_u1_t m_GPIEvent;
10273 
10276  public:
10277  static const CFieldDescriptor
10278  s_fdGPIEvent;
10280 
10282  inline llrp_u1_t
10284  {
10285  return m_GPIEvent;
10286  }
10287 
10289  inline void
10291  llrp_u1_t value)
10292  {
10293  m_GPIEvent = value;
10294  }
10295 
10296 
10297  protected:
10298  llrp_u32_t m_Timeout;
10299 
10302  public:
10303  static const CFieldDescriptor
10304  s_fdTimeout;
10306 
10308  inline llrp_u32_t
10309  getTimeout (void)
10310  {
10311  return m_Timeout;
10312  }
10313 
10315  inline void
10317  llrp_u32_t value)
10318  {
10319  m_Timeout = value;
10320  }
10321 
10322 
10323 
10324 };
10325 
10326 
10359 class CROSpecStopTrigger : public CParameter
10360 {
10361  public:
10362  CROSpecStopTrigger (void);
10363  ~CROSpecStopTrigger (void);
10364 
10367 
10368  static const CFieldDescriptor * const
10369  s_apFieldDescriptorTable[];
10370 
10371  static const CTypeDescriptor
10372  s_typeDescriptor;
10373 
10374  void
10375  decodeFields (
10376  CDecoderStream * pDecoderStream);
10377 
10378  void
10379  assimilateSubParameters (
10380  CErrorDetails * pError);
10381 
10382  void
10383  encode (
10384  CEncoderStream * pEncoderStream) const;
10385 
10386 
10387 
10388  static CElement *
10389  s_construct (void);
10390 
10391  static void
10392  s_decodeFields (
10393  CDecoderStream * pDecoderStream,
10394  CElement * pElement);
10396 
10397 
10398  protected:
10399  EROSpecStopTriggerType m_eROSpecStopTriggerType;
10400 
10403  public:
10404  static const CFieldDescriptor
10405  s_fdROSpecStopTriggerType;
10407 
10409  inline EROSpecStopTriggerType
10411  {
10412  return m_eROSpecStopTriggerType;
10413  }
10414 
10416  inline void
10418  EROSpecStopTriggerType value)
10419  {
10420  m_eROSpecStopTriggerType = value;
10421  }
10422 
10423 
10424  protected:
10425  llrp_u32_t m_DurationTriggerValue;
10426 
10429  public:
10430  static const CFieldDescriptor
10431  s_fdDurationTriggerValue;
10433 
10435  inline llrp_u32_t
10437  {
10438  return m_DurationTriggerValue;
10439  }
10440 
10442  inline void
10444  llrp_u32_t value)
10445  {
10446  m_DurationTriggerValue = value;
10447  }
10448 
10449 
10450 
10451  protected:
10452  CGPITriggerValue * m_pGPITriggerValue;
10453 
10454  public:
10456  inline CGPITriggerValue *
10458  {
10459  return m_pGPITriggerValue;
10460  }
10461 
10463  EResultCode
10464  setGPITriggerValue (
10465  CGPITriggerValue * pValue);
10466 
10467 
10468 };
10469 
10470 
10504 class CAISpec : public CParameter
10505 {
10506  public:
10507  CAISpec (void);
10508  ~CAISpec (void);
10509 
10512 
10513  static const CFieldDescriptor * const
10514  s_apFieldDescriptorTable[];
10515 
10516  static const CTypeDescriptor
10517  s_typeDescriptor;
10518 
10519  void
10520  decodeFields (
10521  CDecoderStream * pDecoderStream);
10522 
10523  void
10524  assimilateSubParameters (
10525  CErrorDetails * pError);
10526 
10527  void
10528  encode (
10529  CEncoderStream * pEncoderStream) const;
10530 
10531 
10532 
10533  static CElement *
10534  s_construct (void);
10535 
10536  static void
10537  s_decodeFields (
10538  CDecoderStream * pDecoderStream,
10539  CElement * pElement);
10541 
10542 
10543  protected:
10544  llrp_u16v_t m_AntennaIDs;
10545 
10548  public:
10549  static const CFieldDescriptor
10550  s_fdAntennaIDs;
10552 
10554  inline llrp_u16v_t
10556  {
10557  return m_AntennaIDs;
10558  }
10559 
10561  inline void
10563  llrp_u16v_t value)
10564  {
10565  m_AntennaIDs = value;
10566  }
10567 
10568 
10569 
10570  protected:
10571  CAISpecStopTrigger * m_pAISpecStopTrigger;
10572 
10573  public:
10575  inline CAISpecStopTrigger *
10577  {
10578  return m_pAISpecStopTrigger;
10579  }
10580 
10582  EResultCode
10583  setAISpecStopTrigger (
10584  CAISpecStopTrigger * pValue);
10585 
10586 
10587  protected:
10588  std::list<CInventoryParameterSpec *> m_listInventoryParameterSpec;
10589 
10590  public:
10592  inline std::list<CInventoryParameterSpec *>::iterator
10594  {
10595  return m_listInventoryParameterSpec.begin();
10596  }
10597 
10599  inline std::list<CInventoryParameterSpec *>::iterator
10601  {
10602  return m_listInventoryParameterSpec.end();
10603  }
10604 
10606  inline void
10608  {
10609  clearSubParameterList ((tListOfParameters *) &m_listInventoryParameterSpec);
10610  }
10611 
10613  inline int
10615  {
10616  return (int) (m_listInventoryParameterSpec.size());
10617  }
10618 
10619  EResultCode
10621  addInventoryParameterSpec (
10622  CInventoryParameterSpec * pValue);
10623 
10624 
10625  protected:
10626  std::list<CParameter *> m_listCustom;
10627 
10628  public:
10630  inline std::list<CParameter *>::iterator
10632  {
10633  return m_listCustom.begin();
10634  }
10635 
10637  inline std::list<CParameter *>::iterator
10638  endCustom (void)
10639  {
10640  return m_listCustom.end();
10641  }
10642 
10644  inline void
10646  {
10647  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10648  }
10649 
10651  inline int
10653  {
10654  return (int) (m_listCustom.size());
10655  }
10656 
10657  EResultCode
10659  addCustom (
10660  CParameter * pValue);
10661 
10662 
10663 };
10664 
10665 
10699 class CAISpecStopTrigger : public CParameter
10700 {
10701  public:
10702  CAISpecStopTrigger (void);
10703  ~CAISpecStopTrigger (void);
10704 
10707 
10708  static const CFieldDescriptor * const
10709  s_apFieldDescriptorTable[];
10710 
10711  static const CTypeDescriptor
10712  s_typeDescriptor;
10713 
10714  void
10715  decodeFields (
10716  CDecoderStream * pDecoderStream);
10717 
10718  void
10719  assimilateSubParameters (
10720  CErrorDetails * pError);
10721 
10722  void
10723  encode (
10724  CEncoderStream * pEncoderStream) const;
10725 
10726 
10727 
10728  static CElement *
10729  s_construct (void);
10730 
10731  static void
10732  s_decodeFields (
10733  CDecoderStream * pDecoderStream,
10734  CElement * pElement);
10736 
10737 
10738  protected:
10739  EAISpecStopTriggerType m_eAISpecStopTriggerType;
10740 
10743  public:
10744  static const CFieldDescriptor
10745  s_fdAISpecStopTriggerType;
10747 
10749  inline EAISpecStopTriggerType
10751  {
10752  return m_eAISpecStopTriggerType;
10753  }
10754 
10756  inline void
10758  EAISpecStopTriggerType value)
10759  {
10760  m_eAISpecStopTriggerType = value;
10761  }
10762 
10763 
10764  protected:
10765  llrp_u32_t m_DurationTrigger;
10766 
10769  public:
10770  static const CFieldDescriptor
10771  s_fdDurationTrigger;
10773 
10775  inline llrp_u32_t
10777  {
10778  return m_DurationTrigger;
10779  }
10780 
10782  inline void
10784  llrp_u32_t value)
10785  {
10786  m_DurationTrigger = value;
10787  }
10788 
10789 
10790 
10791  protected:
10792  CGPITriggerValue * m_pGPITriggerValue;
10793 
10794  public:
10796  inline CGPITriggerValue *
10798  {
10799  return m_pGPITriggerValue;
10800  }
10801 
10803  EResultCode
10804  setGPITriggerValue (
10805  CGPITriggerValue * pValue);
10806 
10807 
10808  protected:
10809  CTagObservationTrigger * m_pTagObservationTrigger;
10810 
10811  public:
10813  inline CTagObservationTrigger *
10815  {
10816  return m_pTagObservationTrigger;
10817  }
10818 
10820  EResultCode
10821  setTagObservationTrigger (
10822  CTagObservationTrigger * pValue);
10823 
10824 
10825 };
10826 
10827 
10863 class CTagObservationTrigger : public CParameter
10864 {
10865  public:
10866  CTagObservationTrigger (void);
10867  ~CTagObservationTrigger (void);
10868 
10871 
10872  static const CFieldDescriptor * const
10873  s_apFieldDescriptorTable[];
10874 
10875  static const CTypeDescriptor
10876  s_typeDescriptor;
10877 
10878  void
10879  decodeFields (
10880  CDecoderStream * pDecoderStream);
10881 
10882  void
10883  assimilateSubParameters (
10884  CErrorDetails * pError);
10885 
10886  void
10887  encode (
10888  CEncoderStream * pEncoderStream) const;
10889 
10890 
10891 
10892  static CElement *
10893  s_construct (void);
10894 
10895  static void
10896  s_decodeFields (
10897  CDecoderStream * pDecoderStream,
10898  CElement * pElement);
10900 
10901 
10902  protected:
10903  ETagObservationTriggerType m_eTriggerType;
10904 
10907  public:
10908  static const CFieldDescriptor
10909  s_fdTriggerType;
10911 
10913  inline ETagObservationTriggerType
10915  {
10916  return m_eTriggerType;
10917  }
10918 
10920  inline void
10922  ETagObservationTriggerType value)
10923  {
10924  m_eTriggerType = value;
10925  }
10926 
10927 
10928  protected:
10929  llrp_u16_t m_NumberOfTags;
10930 
10933  public:
10934  static const CFieldDescriptor
10935  s_fdNumberOfTags;
10937 
10939  inline llrp_u16_t
10941  {
10942  return m_NumberOfTags;
10943  }
10944 
10946  inline void
10948  llrp_u16_t value)
10949  {
10950  m_NumberOfTags = value;
10951  }
10952 
10953 
10954  protected:
10955  llrp_u16_t m_NumberOfAttempts;
10956 
10959  public:
10960  static const CFieldDescriptor
10961  s_fdNumberOfAttempts;
10963 
10965  inline llrp_u16_t
10967  {
10968  return m_NumberOfAttempts;
10969  }
10970 
10972  inline void
10974  llrp_u16_t value)
10975  {
10976  m_NumberOfAttempts = value;
10977  }
10978 
10979 
10980  protected:
10981  llrp_u16_t m_T;
10982 
10985  public:
10986  static const CFieldDescriptor
10987  s_fdT;
10989 
10991  inline llrp_u16_t
10992  getT (void)
10993  {
10994  return m_T;
10995  }
10996 
10998  inline void
11000  llrp_u16_t value)
11001  {
11002  m_T = value;
11003  }
11004 
11005 
11006  protected:
11007  llrp_u32_t m_Timeout;
11008 
11011  public:
11012  static const CFieldDescriptor
11013  s_fdTimeout;
11015 
11017  inline llrp_u32_t
11018  getTimeout (void)
11019  {
11020  return m_Timeout;
11021  }
11022 
11024  inline void
11026  llrp_u32_t value)
11027  {
11028  m_Timeout = value;
11029  }
11030 
11031 
11032 
11033 };
11034 
11035 
11069 class CInventoryParameterSpec : public CParameter
11070 {
11071  public:
11072  CInventoryParameterSpec (void);
11073  ~CInventoryParameterSpec (void);
11074 
11077 
11078  static const CFieldDescriptor * const
11079  s_apFieldDescriptorTable[];
11080 
11081  static const CTypeDescriptor
11082  s_typeDescriptor;
11083 
11084  void
11085  decodeFields (
11086  CDecoderStream * pDecoderStream);
11087 
11088  void
11089  assimilateSubParameters (
11090  CErrorDetails * pError);
11091 
11092  void
11093  encode (
11094  CEncoderStream * pEncoderStream) const;
11095 
11096 
11097 
11098  static CElement *
11099  s_construct (void);
11100 
11101  static void
11102  s_decodeFields (
11103  CDecoderStream * pDecoderStream,
11104  CElement * pElement);
11106 
11107 
11108  protected:
11109  llrp_u16_t m_InventoryParameterSpecID;
11110 
11113  public:
11114  static const CFieldDescriptor
11115  s_fdInventoryParameterSpecID;
11117 
11119  inline llrp_u16_t
11121  {
11122  return m_InventoryParameterSpecID;
11123  }
11124 
11126  inline void
11128  llrp_u16_t value)
11129  {
11130  m_InventoryParameterSpecID = value;
11131  }
11132 
11133 
11134  protected:
11135  EAirProtocols m_eProtocolID;
11136 
11139  public:
11140  static const CFieldDescriptor
11141  s_fdProtocolID;
11143 
11145  inline EAirProtocols
11147  {
11148  return m_eProtocolID;
11149  }
11150 
11152  inline void
11154  EAirProtocols value)
11155  {
11156  m_eProtocolID = value;
11157  }
11158 
11159 
11160 
11161  protected:
11162  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
11163 
11164  public:
11166  inline std::list<CAntennaConfiguration *>::iterator
11168  {
11169  return m_listAntennaConfiguration.begin();
11170  }
11171 
11173  inline std::list<CAntennaConfiguration *>::iterator
11175  {
11176  return m_listAntennaConfiguration.end();
11177  }
11178 
11180  inline void
11182  {
11183  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
11184  }
11185 
11187  inline int
11189  {
11190  return (int) (m_listAntennaConfiguration.size());
11191  }
11192 
11193  EResultCode
11195  addAntennaConfiguration (
11196  CAntennaConfiguration * pValue);
11197 
11198 
11199  protected:
11200  std::list<CParameter *> m_listCustom;
11201 
11202  public:
11204  inline std::list<CParameter *>::iterator
11206  {
11207  return m_listCustom.begin();
11208  }
11209 
11211  inline std::list<CParameter *>::iterator
11212  endCustom (void)
11213  {
11214  return m_listCustom.end();
11215  }
11216 
11218  inline void
11220  {
11221  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11222  }
11223 
11225  inline int
11227  {
11228  return (int) (m_listCustom.size());
11229  }
11230 
11231  EResultCode
11233  addCustom (
11234  CParameter * pValue);
11235 
11236 
11237 };
11238 
11239 
11274 class CRFSurveySpec : public CParameter
11275 {
11276  public:
11277  CRFSurveySpec (void);
11278  ~CRFSurveySpec (void);
11279 
11282 
11283  static const CFieldDescriptor * const
11284  s_apFieldDescriptorTable[];
11285 
11286  static const CTypeDescriptor
11287  s_typeDescriptor;
11288 
11289  void
11290  decodeFields (
11291  CDecoderStream * pDecoderStream);
11292 
11293  void
11294  assimilateSubParameters (
11295  CErrorDetails * pError);
11296 
11297  void
11298  encode (
11299  CEncoderStream * pEncoderStream) const;
11300 
11301 
11302 
11303  static CElement *
11304  s_construct (void);
11305 
11306  static void
11307  s_decodeFields (
11308  CDecoderStream * pDecoderStream,
11309  CElement * pElement);
11311 
11312 
11313  protected:
11314  llrp_u16_t m_AntennaID;
11315 
11318  public:
11319  static const CFieldDescriptor
11320  s_fdAntennaID;
11322 
11324  inline llrp_u16_t
11326  {
11327  return m_AntennaID;
11328  }
11329 
11331  inline void
11333  llrp_u16_t value)
11334  {
11335  m_AntennaID = value;
11336  }
11337 
11338 
11339  protected:
11340  llrp_u32_t m_StartFrequency;
11341 
11344  public:
11345  static const CFieldDescriptor
11346  s_fdStartFrequency;
11348 
11350  inline llrp_u32_t
11352  {
11353  return m_StartFrequency;
11354  }
11355 
11357  inline void
11359  llrp_u32_t value)
11360  {
11361  m_StartFrequency = value;
11362  }
11363 
11364 
11365  protected:
11366  llrp_u32_t m_EndFrequency;
11367 
11370  public:
11371  static const CFieldDescriptor
11372  s_fdEndFrequency;
11374 
11376  inline llrp_u32_t
11378  {
11379  return m_EndFrequency;
11380  }
11381 
11383  inline void
11385  llrp_u32_t value)
11386  {
11387  m_EndFrequency = value;
11388  }
11389 
11390 
11391 
11392  protected:
11393  CRFSurveySpecStopTrigger * m_pRFSurveySpecStopTrigger;
11394 
11395  public:
11397  inline CRFSurveySpecStopTrigger *
11399  {
11400  return m_pRFSurveySpecStopTrigger;
11401  }
11402 
11404  EResultCode
11405  setRFSurveySpecStopTrigger (
11406  CRFSurveySpecStopTrigger * pValue);
11407 
11408 
11409  protected:
11410  std::list<CParameter *> m_listCustom;
11411 
11412  public:
11414  inline std::list<CParameter *>::iterator
11416  {
11417  return m_listCustom.begin();
11418  }
11419 
11421  inline std::list<CParameter *>::iterator
11422  endCustom (void)
11423  {
11424  return m_listCustom.end();
11425  }
11426 
11428  inline void
11430  {
11431  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11432  }
11433 
11435  inline int
11437  {
11438  return (int) (m_listCustom.size());
11439  }
11440 
11441  EResultCode
11443  addCustom (
11444  CParameter * pValue);
11445 
11446 
11447 };
11448 
11449 
11482 class CRFSurveySpecStopTrigger : public CParameter
11483 {
11484  public:
11485  CRFSurveySpecStopTrigger (void);
11486  ~CRFSurveySpecStopTrigger (void);
11487 
11490 
11491  static const CFieldDescriptor * const
11492  s_apFieldDescriptorTable[];
11493 
11494  static const CTypeDescriptor
11495  s_typeDescriptor;
11496 
11497  void
11498  decodeFields (
11499  CDecoderStream * pDecoderStream);
11500 
11501  void
11502  assimilateSubParameters (
11503  CErrorDetails * pError);
11504 
11505  void
11506  encode (
11507  CEncoderStream * pEncoderStream) const;
11508 
11509 
11510 
11511  static CElement *
11512  s_construct (void);
11513 
11514  static void
11515  s_decodeFields (
11516  CDecoderStream * pDecoderStream,
11517  CElement * pElement);
11519 
11520 
11521  protected:
11522  ERFSurveySpecStopTriggerType m_eStopTriggerType;
11523 
11526  public:
11527  static const CFieldDescriptor
11528  s_fdStopTriggerType;
11530 
11532  inline ERFSurveySpecStopTriggerType
11534  {
11535  return m_eStopTriggerType;
11536  }
11537 
11539  inline void
11541  ERFSurveySpecStopTriggerType value)
11542  {
11543  m_eStopTriggerType = value;
11544  }
11545 
11546 
11547  protected:
11548  llrp_u32_t m_DurationPeriod;
11549 
11552  public:
11553  static const CFieldDescriptor
11554  s_fdDurationPeriod;
11556 
11558  inline llrp_u32_t
11560  {
11561  return m_DurationPeriod;
11562  }
11563 
11565  inline void
11567  llrp_u32_t value)
11568  {
11569  m_DurationPeriod = value;
11570  }
11571 
11572 
11573  protected:
11574  llrp_u32_t m_N;
11575 
11578  public:
11579  static const CFieldDescriptor
11580  s_fdN;
11582 
11584  inline llrp_u32_t
11585  getN (void)
11586  {
11587  return m_N;
11588  }
11589 
11591  inline void
11593  llrp_u32_t value)
11594  {
11595  m_N = value;
11596  }
11597 
11598 
11599 
11600 };
11601 
11602 
11642 class CAccessSpec : public CParameter
11643 {
11644  public:
11645  CAccessSpec (void);
11646  ~CAccessSpec (void);
11647 
11650 
11651  static const CFieldDescriptor * const
11652  s_apFieldDescriptorTable[];
11653 
11654  static const CTypeDescriptor
11655  s_typeDescriptor;
11656 
11657  void
11658  decodeFields (
11659  CDecoderStream * pDecoderStream);
11660 
11661  void
11662  assimilateSubParameters (
11663  CErrorDetails * pError);
11664 
11665  void
11666  encode (
11667  CEncoderStream * pEncoderStream) const;
11668 
11669 
11670 
11671  static CElement *
11672  s_construct (void);
11673 
11674  static void
11675  s_decodeFields (
11676  CDecoderStream * pDecoderStream,
11677  CElement * pElement);
11679 
11680 
11681  protected:
11682  llrp_u32_t m_AccessSpecID;
11683 
11686  public:
11687  static const CFieldDescriptor
11688  s_fdAccessSpecID;
11690 
11692  inline llrp_u32_t
11694  {
11695  return m_AccessSpecID;
11696  }
11697 
11699  inline void
11701  llrp_u32_t value)
11702  {
11703  m_AccessSpecID = value;
11704  }
11705 
11706 
11707  protected:
11708  llrp_u16_t m_AntennaID;
11709 
11712  public:
11713  static const CFieldDescriptor
11714  s_fdAntennaID;
11716 
11718  inline llrp_u16_t
11720  {
11721  return m_AntennaID;
11722  }
11723 
11725  inline void
11727  llrp_u16_t value)
11728  {
11729  m_AntennaID = value;
11730  }
11731 
11732 
11733  protected:
11734  EAirProtocols m_eProtocolID;
11735 
11738  public:
11739  static const CFieldDescriptor
11740  s_fdProtocolID;
11742 
11744  inline EAirProtocols
11746  {
11747  return m_eProtocolID;
11748  }
11749 
11751  inline void
11753  EAirProtocols value)
11754  {
11755  m_eProtocolID = value;
11756  }
11757 
11758 
11759  protected:
11760  EAccessSpecState m_eCurrentState;
11761 
11764  public:
11765  static const CFieldDescriptor
11766  s_fdCurrentState;
11768 
11770  inline EAccessSpecState
11772  {
11773  return m_eCurrentState;
11774  }
11775 
11777  inline void
11779  EAccessSpecState value)
11780  {
11781  m_eCurrentState = value;
11782  }
11783 
11784 
11785  protected:
11786  llrp_u32_t m_ROSpecID;
11787 
11790  public:
11791  static const CFieldDescriptor
11792  s_fdROSpecID;
11794 
11796  inline llrp_u32_t
11798  {
11799  return m_ROSpecID;
11800  }
11801 
11803  inline void
11805  llrp_u32_t value)
11806  {
11807  m_ROSpecID = value;
11808  }
11809 
11810 
11811 
11812  protected:
11813  CAccessSpecStopTrigger * m_pAccessSpecStopTrigger;
11814 
11815  public:
11817  inline CAccessSpecStopTrigger *
11819  {
11820  return m_pAccessSpecStopTrigger;
11821  }
11822 
11824  EResultCode
11825  setAccessSpecStopTrigger (
11826  CAccessSpecStopTrigger * pValue);
11827 
11828 
11829  protected:
11830  CAccessCommand * m_pAccessCommand;
11831 
11832  public:
11834  inline CAccessCommand *
11836  {
11837  return m_pAccessCommand;
11838  }
11839 
11841  EResultCode
11842  setAccessCommand (
11843  CAccessCommand * pValue);
11844 
11845 
11846  protected:
11847  CAccessReportSpec * m_pAccessReportSpec;
11848 
11849  public:
11851  inline CAccessReportSpec *
11853  {
11854  return m_pAccessReportSpec;
11855  }
11856 
11858  EResultCode
11859  setAccessReportSpec (
11860  CAccessReportSpec * pValue);
11861 
11862 
11863  protected:
11864  std::list<CParameter *> m_listCustom;
11865 
11866  public:
11868  inline std::list<CParameter *>::iterator
11870  {
11871  return m_listCustom.begin();
11872  }
11873 
11875  inline std::list<CParameter *>::iterator
11876  endCustom (void)
11877  {
11878  return m_listCustom.end();
11879  }
11880 
11882  inline void
11884  {
11885  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11886  }
11887 
11889  inline int
11891  {
11892  return (int) (m_listCustom.size());
11893  }
11894 
11895  EResultCode
11897  addCustom (
11898  CParameter * pValue);
11899 
11900 
11901 };
11902 
11903 
11938 class CAccessSpecStopTrigger : public CParameter
11939 {
11940  public:
11941  CAccessSpecStopTrigger (void);
11942  ~CAccessSpecStopTrigger (void);
11943 
11946 
11947  static const CFieldDescriptor * const
11948  s_apFieldDescriptorTable[];
11949 
11950  static const CTypeDescriptor
11951  s_typeDescriptor;
11952 
11953  void
11954  decodeFields (
11955  CDecoderStream * pDecoderStream);
11956 
11957  void
11958  assimilateSubParameters (
11959  CErrorDetails * pError);
11960 
11961  void
11962  encode (
11963  CEncoderStream * pEncoderStream) const;
11964 
11965 
11966 
11967  static CElement *
11968  s_construct (void);
11969 
11970  static void
11971  s_decodeFields (
11972  CDecoderStream * pDecoderStream,
11973  CElement * pElement);
11975 
11976 
11977  protected:
11978  EAccessSpecStopTriggerType m_eAccessSpecStopTrigger;
11979 
11982  public:
11983  static const CFieldDescriptor
11984  s_fdAccessSpecStopTrigger;
11986 
11988  inline EAccessSpecStopTriggerType
11990  {
11991  return m_eAccessSpecStopTrigger;
11992  }
11993 
11995  inline void
11997  EAccessSpecStopTriggerType value)
11998  {
11999  m_eAccessSpecStopTrigger = value;
12000  }
12001 
12002 
12003  protected:
12004  llrp_u16_t m_OperationCountValue;
12005 
12008  public:
12009  static const CFieldDescriptor
12010  s_fdOperationCountValue;
12012 
12014  inline llrp_u16_t
12016  {
12017  return m_OperationCountValue;
12018  }
12019 
12021  inline void
12023  llrp_u16_t value)
12024  {
12025  m_OperationCountValue = value;
12026  }
12027 
12028 
12029 
12030 };
12031 
12032 
12075 class CAccessCommand : public CParameter
12076 {
12077  public:
12078  CAccessCommand (void);
12079  ~CAccessCommand (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 
12115  protected:
12116  CParameter * m_pAirProtocolTagSpec;
12117 
12118  public:
12120  inline CParameter *
12122  {
12123  return m_pAirProtocolTagSpec;
12124  }
12125 
12127  EResultCode
12128  setAirProtocolTagSpec (
12129  CParameter * pValue);
12130 
12131 
12132  protected:
12133  std::list<CParameter *> m_listAccessCommandOpSpec;
12134 
12135  public:
12137  inline std::list<CParameter *>::iterator
12139  {
12140  return m_listAccessCommandOpSpec.begin();
12141  }
12142 
12144  inline std::list<CParameter *>::iterator
12146  {
12147  return m_listAccessCommandOpSpec.end();
12148  }
12149 
12151  inline void
12153  {
12154  clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpec);
12155  }
12156 
12158  inline int
12160  {
12161  return (int) (m_listAccessCommandOpSpec.size());
12162  }
12163 
12164  EResultCode
12166  addAccessCommandOpSpec (
12167  CParameter * pValue);
12168 
12169 
12170  protected:
12171  std::list<CParameter *> m_listCustom;
12172 
12173  public:
12175  inline std::list<CParameter *>::iterator
12177  {
12178  return m_listCustom.begin();
12179  }
12180 
12182  inline std::list<CParameter *>::iterator
12183  endCustom (void)
12184  {
12185  return m_listCustom.end();
12186  }
12187 
12189  inline void
12191  {
12192  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12193  }
12194 
12196  inline int
12198  {
12199  return (int) (m_listCustom.size());
12200  }
12201 
12202  EResultCode
12204  addCustom (
12205  CParameter * pValue);
12206 
12207 
12208 };
12209 
12210 
12244 class CClientRequestOpSpec : public CParameter
12245 {
12246  public:
12247  CClientRequestOpSpec (void);
12248  ~CClientRequestOpSpec (void);
12249 
12252 
12253  static const CFieldDescriptor * const
12254  s_apFieldDescriptorTable[];
12255 
12256  static const CTypeDescriptor
12257  s_typeDescriptor;
12258 
12259  void
12260  decodeFields (
12261  CDecoderStream * pDecoderStream);
12262 
12263  void
12264  assimilateSubParameters (
12265  CErrorDetails * pError);
12266 
12267  void
12268  encode (
12269  CEncoderStream * pEncoderStream) const;
12270 
12271 
12272 
12273  static CElement *
12274  s_construct (void);
12275 
12276  static void
12277  s_decodeFields (
12278  CDecoderStream * pDecoderStream,
12279  CElement * pElement);
12281 
12282 
12283  protected:
12284  llrp_u16_t m_OpSpecID;
12285 
12288  public:
12289  static const CFieldDescriptor
12290  s_fdOpSpecID;
12292 
12294  inline llrp_u16_t
12296  {
12297  return m_OpSpecID;
12298  }
12299 
12301  inline void
12303  llrp_u16_t value)
12304  {
12305  m_OpSpecID = value;
12306  }
12307 
12308 
12309 
12310 };
12311 
12312 
12345 class CClientRequestResponse : public CParameter
12346 {
12347  public:
12348  CClientRequestResponse (void);
12349  ~CClientRequestResponse (void);
12350 
12353 
12354  static const CFieldDescriptor * const
12355  s_apFieldDescriptorTable[];
12356 
12357  static const CTypeDescriptor
12358  s_typeDescriptor;
12359 
12360  void
12361  decodeFields (
12362  CDecoderStream * pDecoderStream);
12363 
12364  void
12365  assimilateSubParameters (
12366  CErrorDetails * pError);
12367 
12368  void
12369  encode (
12370  CEncoderStream * pEncoderStream) const;
12371 
12372 
12373 
12374  static CElement *
12375  s_construct (void);
12376 
12377  static void
12378  s_decodeFields (
12379  CDecoderStream * pDecoderStream,
12380  CElement * pElement);
12382 
12383 
12384  protected:
12385  llrp_u32_t m_AccessSpecID;
12386 
12389  public:
12390  static const CFieldDescriptor
12391  s_fdAccessSpecID;
12393 
12395  inline llrp_u32_t
12397  {
12398  return m_AccessSpecID;
12399  }
12400 
12402  inline void
12404  llrp_u32_t value)
12405  {
12406  m_AccessSpecID = value;
12407  }
12408 
12409 
12410 
12411  protected:
12412  CEPCData * m_pEPCData;
12413 
12414  public:
12416  inline CEPCData *
12417  getEPCData (void)
12418  {
12419  return m_pEPCData;
12420  }
12421 
12423  EResultCode
12424  setEPCData (
12425  CEPCData * pValue);
12426 
12427 
12428  protected:
12429  std::list<CParameter *> m_listAirProtocolOpSpec;
12430 
12431  public:
12433  inline std::list<CParameter *>::iterator
12435  {
12436  return m_listAirProtocolOpSpec.begin();
12437  }
12438 
12440  inline std::list<CParameter *>::iterator
12442  {
12443  return m_listAirProtocolOpSpec.end();
12444  }
12445 
12447  inline void
12449  {
12450  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolOpSpec);
12451  }
12452 
12454  inline int
12456  {
12457  return (int) (m_listAirProtocolOpSpec.size());
12458  }
12459 
12460  EResultCode
12462  addAirProtocolOpSpec (
12463  CParameter * pValue);
12464 
12465 
12466 };
12467 
12468 
12533 class CLLRPConfigurationStateValue : public CParameter
12534 {
12535  public:
12538 
12541 
12542  static const CFieldDescriptor * const
12543  s_apFieldDescriptorTable[];
12544 
12545  static const CTypeDescriptor
12546  s_typeDescriptor;
12547 
12548  void
12549  decodeFields (
12550  CDecoderStream * pDecoderStream);
12551 
12552  void
12553  assimilateSubParameters (
12554  CErrorDetails * pError);
12555 
12556  void
12557  encode (
12558  CEncoderStream * pEncoderStream) const;
12559 
12560 
12561 
12562  static CElement *
12563  s_construct (void);
12564 
12565  static void
12566  s_decodeFields (
12567  CDecoderStream * pDecoderStream,
12568  CElement * pElement);
12570 
12571 
12572  protected:
12573  llrp_u32_t m_LLRPConfigurationStateValue;
12574 
12577  public:
12578  static const CFieldDescriptor
12579  s_fdLLRPConfigurationStateValue;
12581 
12583  inline llrp_u32_t
12585  {
12586  return m_LLRPConfigurationStateValue;
12587  }
12588 
12590  inline void
12592  llrp_u32_t value)
12593  {
12594  m_LLRPConfigurationStateValue = value;
12595  }
12596 
12597 
12598 
12599 };
12600 
12601 
12638 class CIdentification : public CParameter
12639 {
12640  public:
12641  CIdentification (void);
12642  ~CIdentification (void);
12643 
12646 
12647  static const CFieldDescriptor * const
12648  s_apFieldDescriptorTable[];
12649 
12650  static const CTypeDescriptor
12651  s_typeDescriptor;
12652 
12653  void
12654  decodeFields (
12655  CDecoderStream * pDecoderStream);
12656 
12657  void
12658  assimilateSubParameters (
12659  CErrorDetails * pError);
12660 
12661  void
12662  encode (
12663  CEncoderStream * pEncoderStream) const;
12664 
12665 
12666 
12667  static CElement *
12668  s_construct (void);
12669 
12670  static void
12671  s_decodeFields (
12672  CDecoderStream * pDecoderStream,
12673  CElement * pElement);
12675 
12676 
12677  protected:
12678  EIdentificationType m_eIDType;
12679 
12682  public:
12683  static const CFieldDescriptor
12684  s_fdIDType;
12686 
12688  inline EIdentificationType
12689  getIDType (void)
12690  {
12691  return m_eIDType;
12692  }
12693 
12695  inline void
12697  EIdentificationType value)
12698  {
12699  m_eIDType = value;
12700  }
12701 
12702 
12703  protected:
12704  llrp_u8v_t m_ReaderID;
12705 
12708  public:
12709  static const CFieldDescriptor
12710  s_fdReaderID;
12712 
12714  inline llrp_u8v_t
12716  {
12717  return m_ReaderID;
12718  }
12719 
12721  inline void
12723  llrp_u8v_t value)
12724  {
12725  m_ReaderID = value;
12726  }
12727 
12728 
12729 
12730 };
12731 
12732 
12772 class CGPOWriteData : public CParameter
12773 {
12774  public:
12775  CGPOWriteData (void);
12776  ~CGPOWriteData (void);
12777 
12780 
12781  static const CFieldDescriptor * const
12782  s_apFieldDescriptorTable[];
12783 
12784  static const CTypeDescriptor
12785  s_typeDescriptor;
12786 
12787  void
12788  decodeFields (
12789  CDecoderStream * pDecoderStream);
12790 
12791  void
12792  assimilateSubParameters (
12793  CErrorDetails * pError);
12794 
12795  void
12796  encode (
12797  CEncoderStream * pEncoderStream) const;
12798 
12799 
12800 
12801  static CElement *
12802  s_construct (void);
12803 
12804  static void
12805  s_decodeFields (
12806  CDecoderStream * pDecoderStream,
12807  CElement * pElement);
12809 
12810 
12811  protected:
12812  llrp_u16_t m_GPOPortNumber;
12813 
12816  public:
12817  static const CFieldDescriptor
12818  s_fdGPOPortNumber;
12820 
12822  inline llrp_u16_t
12824  {
12825  return m_GPOPortNumber;
12826  }
12827 
12829  inline void
12831  llrp_u16_t value)
12832  {
12833  m_GPOPortNumber = value;
12834  }
12835 
12836 
12837  protected:
12838  llrp_u1_t m_GPOData;
12839 
12842  public:
12843  static const CFieldDescriptor
12844  s_fdGPOData;
12846 
12848  inline llrp_u1_t
12849  getGPOData (void)
12850  {
12851  return m_GPOData;
12852  }
12853 
12855  inline void
12857  llrp_u1_t value)
12858  {
12859  m_GPOData = value;
12860  }
12861 
12862 
12863 
12864 };
12865 
12866 
12898 class CKeepaliveSpec : public CParameter
12899 {
12900  public:
12901  CKeepaliveSpec (void);
12902  ~CKeepaliveSpec (void);
12903 
12906 
12907  static const CFieldDescriptor * const
12908  s_apFieldDescriptorTable[];
12909 
12910  static const CTypeDescriptor
12911  s_typeDescriptor;
12912 
12913  void
12914  decodeFields (
12915  CDecoderStream * pDecoderStream);
12916 
12917  void
12918  assimilateSubParameters (
12919  CErrorDetails * pError);
12920 
12921  void
12922  encode (
12923  CEncoderStream * pEncoderStream) const;
12924 
12925 
12926 
12927  static CElement *
12928  s_construct (void);
12929 
12930  static void
12931  s_decodeFields (
12932  CDecoderStream * pDecoderStream,
12933  CElement * pElement);
12935 
12936 
12937  protected:
12938  EKeepaliveTriggerType m_eKeepaliveTriggerType;
12939 
12942  public:
12943  static const CFieldDescriptor
12944  s_fdKeepaliveTriggerType;
12946 
12948  inline EKeepaliveTriggerType
12950  {
12951  return m_eKeepaliveTriggerType;
12952  }
12953 
12955  inline void
12957  EKeepaliveTriggerType value)
12958  {
12959  m_eKeepaliveTriggerType = value;
12960  }
12961 
12962 
12963  protected:
12964  llrp_u32_t m_PeriodicTriggerValue;
12965 
12968  public:
12969  static const CFieldDescriptor
12970  s_fdPeriodicTriggerValue;
12972 
12974  inline llrp_u32_t
12976  {
12977  return m_PeriodicTriggerValue;
12978  }
12979 
12981  inline void
12983  llrp_u32_t value)
12984  {
12985  m_PeriodicTriggerValue = value;
12986  }
12987 
12988 
12989 
12990 };
12991 
12992 
13026 class CAntennaProperties : public CParameter
13027 {
13028  public:
13029  CAntennaProperties (void);
13030  ~CAntennaProperties (void);
13031 
13034 
13035  static const CFieldDescriptor * const
13036  s_apFieldDescriptorTable[];
13037 
13038  static const CTypeDescriptor
13039  s_typeDescriptor;
13040 
13041  void
13042  decodeFields (
13043  CDecoderStream * pDecoderStream);
13044 
13045  void
13046  assimilateSubParameters (
13047  CErrorDetails * pError);
13048 
13049  void
13050  encode (
13051  CEncoderStream * pEncoderStream) const;
13052 
13053 
13054 
13055  static CElement *
13056  s_construct (void);
13057 
13058  static void
13059  s_decodeFields (
13060  CDecoderStream * pDecoderStream,
13061  CElement * pElement);
13063 
13064 
13065  protected:
13066  llrp_u1_t m_AntennaConnected;
13067 
13070  public:
13071  static const CFieldDescriptor
13072  s_fdAntennaConnected;
13074 
13076  inline llrp_u1_t
13078  {
13079  return m_AntennaConnected;
13080  }
13081 
13083  inline void
13085  llrp_u1_t value)
13086  {
13087  m_AntennaConnected = value;
13088  }
13089 
13090 
13091  protected:
13092  llrp_u16_t m_AntennaID;
13093 
13096  public:
13097  static const CFieldDescriptor
13098  s_fdAntennaID;
13100 
13102  inline llrp_u16_t
13104  {
13105  return m_AntennaID;
13106  }
13107 
13109  inline void
13111  llrp_u16_t value)
13112  {
13113  m_AntennaID = value;
13114  }
13115 
13116 
13117  protected:
13118  llrp_s16_t m_AntennaGain;
13119 
13122  public:
13123  static const CFieldDescriptor
13124  s_fdAntennaGain;
13126 
13128  inline llrp_s16_t
13130  {
13131  return m_AntennaGain;
13132  }
13133 
13135  inline void
13137  llrp_s16_t value)
13138  {
13139  m_AntennaGain = value;
13140  }
13141 
13142 
13143 
13144 };
13145 
13146 
13180 class CAntennaConfiguration : public CParameter
13181 {
13182  public:
13183  CAntennaConfiguration (void);
13184  ~CAntennaConfiguration (void);
13185 
13188 
13189  static const CFieldDescriptor * const
13190  s_apFieldDescriptorTable[];
13191 
13192  static const CTypeDescriptor
13193  s_typeDescriptor;
13194 
13195  void
13196  decodeFields (
13197  CDecoderStream * pDecoderStream);
13198 
13199  void
13200  assimilateSubParameters (
13201  CErrorDetails * pError);
13202 
13203  void
13204  encode (
13205  CEncoderStream * pEncoderStream) const;
13206 
13207 
13208 
13209  static CElement *
13210  s_construct (void);
13211 
13212  static void
13213  s_decodeFields (
13214  CDecoderStream * pDecoderStream,
13215  CElement * pElement);
13217 
13218 
13219  protected:
13220  llrp_u16_t m_AntennaID;
13221 
13224  public:
13225  static const CFieldDescriptor
13226  s_fdAntennaID;
13228 
13230  inline llrp_u16_t
13232  {
13233  return m_AntennaID;
13234  }
13235 
13237  inline void
13239  llrp_u16_t value)
13240  {
13241  m_AntennaID = value;
13242  }
13243 
13244 
13245 
13246  protected:
13247  CRFReceiver * m_pRFReceiver;
13248 
13249  public:
13251  inline CRFReceiver *
13253  {
13254  return m_pRFReceiver;
13255  }
13256 
13258  EResultCode
13259  setRFReceiver (
13260  CRFReceiver * pValue);
13261 
13262 
13263  protected:
13264  CRFTransmitter * m_pRFTransmitter;
13265 
13266  public:
13268  inline CRFTransmitter *
13270  {
13271  return m_pRFTransmitter;
13272  }
13273 
13275  EResultCode
13276  setRFTransmitter (
13277  CRFTransmitter * pValue);
13278 
13279 
13280  protected:
13281  std::list<CParameter *> m_listAirProtocolInventoryCommandSettings;
13282 
13283  public:
13285  inline std::list<CParameter *>::iterator
13287  {
13288  return m_listAirProtocolInventoryCommandSettings.begin();
13289  }
13290 
13292  inline std::list<CParameter *>::iterator
13294  {
13295  return m_listAirProtocolInventoryCommandSettings.end();
13296  }
13297 
13299  inline void
13301  {
13302  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolInventoryCommandSettings);
13303  }
13304 
13306  inline int
13308  {
13309  return (int) (m_listAirProtocolInventoryCommandSettings.size());
13310  }
13311 
13312  EResultCode
13314  addAirProtocolInventoryCommandSettings (
13315  CParameter * pValue);
13316 
13317 
13318 };
13319 
13320 
13351 class CRFReceiver : public CParameter
13352 {
13353  public:
13354  CRFReceiver (void);
13355  ~CRFReceiver (void);
13356 
13359 
13360  static const CFieldDescriptor * const
13361  s_apFieldDescriptorTable[];
13362 
13363  static const CTypeDescriptor
13364  s_typeDescriptor;
13365 
13366  void
13367  decodeFields (
13368  CDecoderStream * pDecoderStream);
13369 
13370  void
13371  assimilateSubParameters (
13372  CErrorDetails * pError);
13373 
13374  void
13375  encode (
13376  CEncoderStream * pEncoderStream) const;
13377 
13378 
13379 
13380  static CElement *
13381  s_construct (void);
13382 
13383  static void
13384  s_decodeFields (
13385  CDecoderStream * pDecoderStream,
13386  CElement * pElement);
13388 
13389 
13390  protected:
13391  llrp_u16_t m_ReceiverSensitivity;
13392 
13395  public:
13396  static const CFieldDescriptor
13397  s_fdReceiverSensitivity;
13399 
13401  inline llrp_u16_t
13403  {
13404  return m_ReceiverSensitivity;
13405  }
13406 
13408  inline void
13410  llrp_u16_t value)
13411  {
13412  m_ReceiverSensitivity = value;
13413  }
13414 
13415 
13416 
13417 };
13418 
13419 
13452 class CRFTransmitter : public CParameter
13453 {
13454  public:
13455  CRFTransmitter (void);
13456  ~CRFTransmitter (void);
13457 
13460 
13461  static const CFieldDescriptor * const
13462  s_apFieldDescriptorTable[];
13463 
13464  static const CTypeDescriptor
13465  s_typeDescriptor;
13466 
13467  void
13468  decodeFields (
13469  CDecoderStream * pDecoderStream);
13470 
13471  void
13472  assimilateSubParameters (
13473  CErrorDetails * pError);
13474 
13475  void
13476  encode (
13477  CEncoderStream * pEncoderStream) const;
13478 
13479 
13480 
13481  static CElement *
13482  s_construct (void);
13483 
13484  static void
13485  s_decodeFields (
13486  CDecoderStream * pDecoderStream,
13487  CElement * pElement);
13489 
13490 
13491  protected:
13492  llrp_u16_t m_HopTableID;
13493 
13496  public:
13497  static const CFieldDescriptor
13498  s_fdHopTableID;
13500 
13502  inline llrp_u16_t
13504  {
13505  return m_HopTableID;
13506  }
13507 
13509  inline void
13511  llrp_u16_t value)
13512  {
13513  m_HopTableID = value;
13514  }
13515 
13516 
13517  protected:
13518  llrp_u16_t m_ChannelIndex;
13519 
13522  public:
13523  static const CFieldDescriptor
13524  s_fdChannelIndex;
13526 
13528  inline llrp_u16_t
13530  {
13531  return m_ChannelIndex;
13532  }
13533 
13535  inline void
13537  llrp_u16_t value)
13538  {
13539  m_ChannelIndex = value;
13540  }
13541 
13542 
13543  protected:
13544  llrp_u16_t m_TransmitPower;
13545 
13548  public:
13549  static const CFieldDescriptor
13550  s_fdTransmitPower;
13552 
13554  inline llrp_u16_t
13556  {
13557  return m_TransmitPower;
13558  }
13559 
13561  inline void
13563  llrp_u16_t value)
13564  {
13565  m_TransmitPower = value;
13566  }
13567 
13568 
13569 
13570 };
13571 
13572 
13616 class CGPIPortCurrentState : public CParameter
13617 {
13618  public:
13619  CGPIPortCurrentState (void);
13620  ~CGPIPortCurrentState (void);
13621 
13624 
13625  static const CFieldDescriptor * const
13626  s_apFieldDescriptorTable[];
13627 
13628  static const CTypeDescriptor
13629  s_typeDescriptor;
13630 
13631  void
13632  decodeFields (
13633  CDecoderStream * pDecoderStream);
13634 
13635  void
13636  assimilateSubParameters (
13637  CErrorDetails * pError);
13638 
13639  void
13640  encode (
13641  CEncoderStream * pEncoderStream) const;
13642 
13643 
13644 
13645  static CElement *
13646  s_construct (void);
13647 
13648  static void
13649  s_decodeFields (
13650  CDecoderStream * pDecoderStream,
13651  CElement * pElement);
13653 
13654 
13655  protected:
13656  llrp_u16_t m_GPIPortNum;
13657 
13660  public:
13661  static const CFieldDescriptor
13662  s_fdGPIPortNum;
13664 
13666  inline llrp_u16_t
13668  {
13669  return m_GPIPortNum;
13670  }
13671 
13673  inline void
13675  llrp_u16_t value)
13676  {
13677  m_GPIPortNum = value;
13678  }
13679 
13680 
13681  protected:
13682  llrp_u1_t m_Config;
13683 
13686  public:
13687  static const CFieldDescriptor
13688  s_fdConfig;
13690 
13692  inline llrp_u1_t
13693  getConfig (void)
13694  {
13695  return m_Config;
13696  }
13697 
13699  inline void
13701  llrp_u1_t value)
13702  {
13703  m_Config = value;
13704  }
13705 
13706 
13707  protected:
13708  EGPIPortState m_eState;
13709 
13712  public:
13713  static const CFieldDescriptor
13714  s_fdState;
13716 
13718  inline EGPIPortState
13719  getState (void)
13720  {
13721  return m_eState;
13722  }
13723 
13725  inline void
13727  EGPIPortState value)
13728  {
13729  m_eState = value;
13730  }
13731 
13732 
13733 
13734 };
13735 
13736 
13768 class CEventsAndReports : public CParameter
13769 {
13770  public:
13771  CEventsAndReports (void);
13772  ~CEventsAndReports (void);
13773 
13776 
13777  static const CFieldDescriptor * const
13778  s_apFieldDescriptorTable[];
13779 
13780  static const CTypeDescriptor
13781  s_typeDescriptor;
13782 
13783  void
13784  decodeFields (
13785  CDecoderStream * pDecoderStream);
13786 
13787  void
13788  assimilateSubParameters (
13789  CErrorDetails * pError);
13790 
13791  void
13792  encode (
13793  CEncoderStream * pEncoderStream) const;
13794 
13795 
13796 
13797  static CElement *
13798  s_construct (void);
13799 
13800  static void
13801  s_decodeFields (
13802  CDecoderStream * pDecoderStream,
13803  CElement * pElement);
13805 
13806 
13807  protected:
13808  llrp_u1_t m_HoldEventsAndReportsUponReconnect;
13809 
13812  public:
13813  static const CFieldDescriptor
13814  s_fdHoldEventsAndReportsUponReconnect;
13816 
13818  inline llrp_u1_t
13820  {
13821  return m_HoldEventsAndReportsUponReconnect;
13822  }
13823 
13825  inline void
13827  llrp_u1_t value)
13828  {
13829  m_HoldEventsAndReportsUponReconnect = value;
13830  }
13831 
13832 
13833 
13834 };
13835 
13836 
13879 class CROReportSpec : public CParameter
13880 {
13881  public:
13882  CROReportSpec (void);
13883  ~CROReportSpec (void);
13884 
13887 
13888  static const CFieldDescriptor * const
13889  s_apFieldDescriptorTable[];
13890 
13891  static const CTypeDescriptor
13892  s_typeDescriptor;
13893 
13894  void
13895  decodeFields (
13896  CDecoderStream * pDecoderStream);
13897 
13898  void
13899  assimilateSubParameters (
13900  CErrorDetails * pError);
13901 
13902  void
13903  encode (
13904  CEncoderStream * pEncoderStream) const;
13905 
13906 
13907 
13908  static CElement *
13909  s_construct (void);
13910 
13911  static void
13912  s_decodeFields (
13913  CDecoderStream * pDecoderStream,
13914  CElement * pElement);
13916 
13917 
13918  protected:
13919  EROReportTriggerType m_eROReportTrigger;
13920 
13923  public:
13924  static const CFieldDescriptor
13925  s_fdROReportTrigger;
13927 
13929  inline EROReportTriggerType
13931  {
13932  return m_eROReportTrigger;
13933  }
13934 
13936  inline void
13938  EROReportTriggerType value)
13939  {
13940  m_eROReportTrigger = value;
13941  }
13942 
13943 
13944  protected:
13945  llrp_u16_t m_N;
13946 
13949  public:
13950  static const CFieldDescriptor
13951  s_fdN;
13953 
13955  inline llrp_u16_t
13956  getN (void)
13957  {
13958  return m_N;
13959  }
13960 
13962  inline void
13964  llrp_u16_t value)
13965  {
13966  m_N = value;
13967  }
13968 
13969 
13970 
13971  protected:
13972  CTagReportContentSelector * m_pTagReportContentSelector;
13973 
13974  public:
13976  inline CTagReportContentSelector *
13978  {
13979  return m_pTagReportContentSelector;
13980  }
13981 
13983  EResultCode
13984  setTagReportContentSelector (
13985  CTagReportContentSelector * pValue);
13986 
13987 
13988  protected:
13989  std::list<CParameter *> m_listCustom;
13990 
13991  public:
13993  inline std::list<CParameter *>::iterator
13995  {
13996  return m_listCustom.begin();
13997  }
13998 
14000  inline std::list<CParameter *>::iterator
14001  endCustom (void)
14002  {
14003  return m_listCustom.end();
14004  }
14005 
14007  inline void
14009  {
14010  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14011  }
14012 
14014  inline int
14016  {
14017  return (int) (m_listCustom.size());
14018  }
14019 
14020  EResultCode
14022  addCustom (
14023  CParameter * pValue);
14024 
14025 
14026 };
14027 
14028 
14070 class CTagReportContentSelector : public CParameter
14071 {
14072  public:
14074  ~CTagReportContentSelector (void);
14075 
14078 
14079  static const CFieldDescriptor * const
14080  s_apFieldDescriptorTable[];
14081 
14082  static const CTypeDescriptor
14083  s_typeDescriptor;
14084 
14085  void
14086  decodeFields (
14087  CDecoderStream * pDecoderStream);
14088 
14089  void
14090  assimilateSubParameters (
14091  CErrorDetails * pError);
14092 
14093  void
14094  encode (
14095  CEncoderStream * pEncoderStream) const;
14096 
14097 
14098 
14099  static CElement *
14100  s_construct (void);
14101 
14102  static void
14103  s_decodeFields (
14104  CDecoderStream * pDecoderStream,
14105  CElement * pElement);
14107 
14108 
14109  protected:
14110  llrp_u1_t m_EnableROSpecID;
14111 
14114  public:
14115  static const CFieldDescriptor
14116  s_fdEnableROSpecID;
14118 
14120  inline llrp_u1_t
14122  {
14123  return m_EnableROSpecID;
14124  }
14125 
14127  inline void
14129  llrp_u1_t value)
14130  {
14131  m_EnableROSpecID = value;
14132  }
14133 
14134 
14135  protected:
14136  llrp_u1_t m_EnableSpecIndex;
14137 
14140  public:
14141  static const CFieldDescriptor
14142  s_fdEnableSpecIndex;
14144 
14146  inline llrp_u1_t
14148  {
14149  return m_EnableSpecIndex;
14150  }
14151 
14153  inline void
14155  llrp_u1_t value)
14156  {
14157  m_EnableSpecIndex = value;
14158  }
14159 
14160 
14161  protected:
14162  llrp_u1_t m_EnableInventoryParameterSpecID;
14163 
14166  public:
14167  static const CFieldDescriptor
14168  s_fdEnableInventoryParameterSpecID;
14170 
14172  inline llrp_u1_t
14174  {
14175  return m_EnableInventoryParameterSpecID;
14176  }
14177 
14179  inline void
14181  llrp_u1_t value)
14182  {
14183  m_EnableInventoryParameterSpecID = value;
14184  }
14185 
14186 
14187  protected:
14188  llrp_u1_t m_EnableAntennaID;
14189 
14192  public:
14193  static const CFieldDescriptor
14194  s_fdEnableAntennaID;
14196 
14198  inline llrp_u1_t
14200  {
14201  return m_EnableAntennaID;
14202  }
14203 
14205  inline void
14207  llrp_u1_t value)
14208  {
14209  m_EnableAntennaID = value;
14210  }
14211 
14212 
14213  protected:
14214  llrp_u1_t m_EnableChannelIndex;
14215 
14218  public:
14219  static const CFieldDescriptor
14220  s_fdEnableChannelIndex;
14222 
14224  inline llrp_u1_t
14226  {
14227  return m_EnableChannelIndex;
14228  }
14229 
14231  inline void
14233  llrp_u1_t value)
14234  {
14235  m_EnableChannelIndex = value;
14236  }
14237 
14238 
14239  protected:
14240  llrp_u1_t m_EnablePeakRSSI;
14241 
14244  public:
14245  static const CFieldDescriptor
14246  s_fdEnablePeakRSSI;
14248 
14250  inline llrp_u1_t
14252  {
14253  return m_EnablePeakRSSI;
14254  }
14255 
14257  inline void
14259  llrp_u1_t value)
14260  {
14261  m_EnablePeakRSSI = value;
14262  }
14263 
14264 
14265  protected:
14266  llrp_u1_t m_EnableFirstSeenTimestamp;
14267 
14270  public:
14271  static const CFieldDescriptor
14272  s_fdEnableFirstSeenTimestamp;
14274 
14276  inline llrp_u1_t
14278  {
14279  return m_EnableFirstSeenTimestamp;
14280  }
14281 
14283  inline void
14285  llrp_u1_t value)
14286  {
14287  m_EnableFirstSeenTimestamp = value;
14288  }
14289 
14290 
14291  protected:
14292  llrp_u1_t m_EnableLastSeenTimestamp;
14293 
14296  public:
14297  static const CFieldDescriptor
14298  s_fdEnableLastSeenTimestamp;
14300 
14302  inline llrp_u1_t
14304  {
14305  return m_EnableLastSeenTimestamp;
14306  }
14307 
14309  inline void
14311  llrp_u1_t value)
14312  {
14313  m_EnableLastSeenTimestamp = value;
14314  }
14315 
14316 
14317  protected:
14318  llrp_u1_t m_EnableTagSeenCount;
14319 
14322  public:
14323  static const CFieldDescriptor
14324  s_fdEnableTagSeenCount;
14326 
14328  inline llrp_u1_t
14330  {
14331  return m_EnableTagSeenCount;
14332  }
14333 
14335  inline void
14337  llrp_u1_t value)
14338  {
14339  m_EnableTagSeenCount = value;
14340  }
14341 
14342 
14343  protected:
14344  llrp_u1_t m_EnableAccessSpecID;
14345 
14348  public:
14349  static const CFieldDescriptor
14350  s_fdEnableAccessSpecID;
14352 
14354  inline llrp_u1_t
14356  {
14357  return m_EnableAccessSpecID;
14358  }
14359 
14361  inline void
14363  llrp_u1_t value)
14364  {
14365  m_EnableAccessSpecID = value;
14366  }
14367 
14368 
14369 
14370  protected:
14371  std::list<CParameter *> m_listAirProtocolEPCMemorySelector;
14372 
14373  public:
14375  inline std::list<CParameter *>::iterator
14377  {
14378  return m_listAirProtocolEPCMemorySelector.begin();
14379  }
14380 
14382  inline std::list<CParameter *>::iterator
14384  {
14385  return m_listAirProtocolEPCMemorySelector.end();
14386  }
14387 
14389  inline void
14391  {
14392  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolEPCMemorySelector);
14393  }
14394 
14396  inline int
14398  {
14399  return (int) (m_listAirProtocolEPCMemorySelector.size());
14400  }
14401 
14402  EResultCode
14404  addAirProtocolEPCMemorySelector (
14405  CParameter * pValue);
14406 
14407 
14408 };
14409 
14410 
14441 class CAccessReportSpec : public CParameter
14442 {
14443  public:
14444  CAccessReportSpec (void);
14445  ~CAccessReportSpec (void);
14446 
14449 
14450  static const CFieldDescriptor * const
14451  s_apFieldDescriptorTable[];
14452 
14453  static const CTypeDescriptor
14454  s_typeDescriptor;
14455 
14456  void
14457  decodeFields (
14458  CDecoderStream * pDecoderStream);
14459 
14460  void
14461  assimilateSubParameters (
14462  CErrorDetails * pError);
14463 
14464  void
14465  encode (
14466  CEncoderStream * pEncoderStream) const;
14467 
14468 
14469 
14470  static CElement *
14471  s_construct (void);
14472 
14473  static void
14474  s_decodeFields (
14475  CDecoderStream * pDecoderStream,
14476  CElement * pElement);
14478 
14479 
14480  protected:
14481  EAccessReportTriggerType m_eAccessReportTrigger;
14482 
14485  public:
14486  static const CFieldDescriptor
14487  s_fdAccessReportTrigger;
14489 
14491  inline EAccessReportTriggerType
14493  {
14494  return m_eAccessReportTrigger;
14495  }
14496 
14498  inline void
14500  EAccessReportTriggerType value)
14501  {
14502  m_eAccessReportTrigger = value;
14503  }
14504 
14505 
14506 
14507 };
14508 
14509 
14679 class CTagReportData : public CParameter
14680 {
14681  public:
14682  CTagReportData (void);
14683  ~CTagReportData (void);
14684 
14687 
14688  static const CFieldDescriptor * const
14689  s_apFieldDescriptorTable[];
14690 
14691  static const CTypeDescriptor
14692  s_typeDescriptor;
14693 
14694  void
14695  decodeFields (
14696  CDecoderStream * pDecoderStream);
14697 
14698  void
14699  assimilateSubParameters (
14700  CErrorDetails * pError);
14701 
14702  void
14703  encode (
14704  CEncoderStream * pEncoderStream) const;
14705 
14706 
14707 
14708  static CElement *
14709  s_construct (void);
14710 
14711  static void
14712  s_decodeFields (
14713  CDecoderStream * pDecoderStream,
14714  CElement * pElement);
14716 
14717 
14718 
14719  protected:
14720  CParameter * m_pEPCParameter;
14721 
14722  public:
14724  inline CParameter *
14726  {
14727  return m_pEPCParameter;
14728  }
14729 
14731  EResultCode
14732  setEPCParameter (
14733  CParameter * pValue);
14734 
14735 
14736  protected:
14737  CROSpecID * m_pROSpecID;
14738 
14739  public:
14741  inline CROSpecID *
14743  {
14744  return m_pROSpecID;
14745  }
14746 
14748  EResultCode
14749  setROSpecID (
14750  CROSpecID * pValue);
14751 
14752 
14753  protected:
14754  CSpecIndex * m_pSpecIndex;
14755 
14756  public:
14758  inline CSpecIndex *
14760  {
14761  return m_pSpecIndex;
14762  }
14763 
14765  EResultCode
14766  setSpecIndex (
14767  CSpecIndex * pValue);
14768 
14769 
14770  protected:
14771  CInventoryParameterSpecID * m_pInventoryParameterSpecID;
14772 
14773  public:
14775  inline CInventoryParameterSpecID *
14777  {
14778  return m_pInventoryParameterSpecID;
14779  }
14780 
14782  EResultCode
14783  setInventoryParameterSpecID (
14784  CInventoryParameterSpecID * pValue);
14785 
14786 
14787  protected:
14788  CAntennaID * m_pAntennaID;
14789 
14790  public:
14792  inline CAntennaID *
14794  {
14795  return m_pAntennaID;
14796  }
14797 
14799  EResultCode
14800  setAntennaID (
14801  CAntennaID * pValue);
14802 
14803 
14804  protected:
14805  CPeakRSSI * m_pPeakRSSI;
14806 
14807  public:
14809  inline CPeakRSSI *
14811  {
14812  return m_pPeakRSSI;
14813  }
14814 
14816  EResultCode
14817  setPeakRSSI (
14818  CPeakRSSI * pValue);
14819 
14820 
14821  protected:
14822  CChannelIndex * m_pChannelIndex;
14823 
14824  public:
14826  inline CChannelIndex *
14828  {
14829  return m_pChannelIndex;
14830  }
14831 
14833  EResultCode
14834  setChannelIndex (
14835  CChannelIndex * pValue);
14836 
14837 
14838  protected:
14839  CFirstSeenTimestampUTC * m_pFirstSeenTimestampUTC;
14840 
14841  public:
14843  inline CFirstSeenTimestampUTC *
14845  {
14846  return m_pFirstSeenTimestampUTC;
14847  }
14848 
14850  EResultCode
14851  setFirstSeenTimestampUTC (
14852  CFirstSeenTimestampUTC * pValue);
14853 
14854 
14855  protected:
14856  CFirstSeenTimestampUptime * m_pFirstSeenTimestampUptime;
14857 
14858  public:
14860  inline CFirstSeenTimestampUptime *
14862  {
14863  return m_pFirstSeenTimestampUptime;
14864  }
14865 
14867  EResultCode
14868  setFirstSeenTimestampUptime (
14869  CFirstSeenTimestampUptime * pValue);
14870 
14871 
14872  protected:
14873  CLastSeenTimestampUTC * m_pLastSeenTimestampUTC;
14874 
14875  public:
14877  inline CLastSeenTimestampUTC *
14879  {
14880  return m_pLastSeenTimestampUTC;
14881  }
14882 
14884  EResultCode
14885  setLastSeenTimestampUTC (
14886  CLastSeenTimestampUTC * pValue);
14887 
14888 
14889  protected:
14890  CLastSeenTimestampUptime * m_pLastSeenTimestampUptime;
14891 
14892  public:
14894  inline CLastSeenTimestampUptime *
14896  {
14897  return m_pLastSeenTimestampUptime;
14898  }
14899 
14901  EResultCode
14902  setLastSeenTimestampUptime (
14903  CLastSeenTimestampUptime * pValue);
14904 
14905 
14906  protected:
14907  CTagSeenCount * m_pTagSeenCount;
14908 
14909  public:
14911  inline CTagSeenCount *
14913  {
14914  return m_pTagSeenCount;
14915  }
14916 
14918  EResultCode
14919  setTagSeenCount (
14920  CTagSeenCount * pValue);
14921 
14922 
14923  protected:
14924  std::list<CParameter *> m_listAirProtocolTagData;
14925 
14926  public:
14928  inline std::list<CParameter *>::iterator
14930  {
14931  return m_listAirProtocolTagData.begin();
14932  }
14933 
14935  inline std::list<CParameter *>::iterator
14937  {
14938  return m_listAirProtocolTagData.end();
14939  }
14940 
14942  inline void
14944  {
14945  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolTagData);
14946  }
14947 
14949  inline int
14951  {
14952  return (int) (m_listAirProtocolTagData.size());
14953  }
14954 
14955  EResultCode
14957  addAirProtocolTagData (
14958  CParameter * pValue);
14959 
14960 
14961  protected:
14962  CAccessSpecID * m_pAccessSpecID;
14963 
14964  public:
14966  inline CAccessSpecID *
14968  {
14969  return m_pAccessSpecID;
14970  }
14971 
14973  EResultCode
14974  setAccessSpecID (
14975  CAccessSpecID * pValue);
14976 
14977 
14978  protected:
14979  std::list<CParameter *> m_listAccessCommandOpSpecResult;
14980 
14981  public:
14983  inline std::list<CParameter *>::iterator
14985  {
14986  return m_listAccessCommandOpSpecResult.begin();
14987  }
14988 
14990  inline std::list<CParameter *>::iterator
14992  {
14993  return m_listAccessCommandOpSpecResult.end();
14994  }
14995 
14997  inline void
14999  {
15000  clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpecResult);
15001  }
15002 
15004  inline int
15006  {
15007  return (int) (m_listAccessCommandOpSpecResult.size());
15008  }
15009 
15010  EResultCode
15012  addAccessCommandOpSpecResult (
15013  CParameter * pValue);
15014 
15015 
15016  protected:
15017  std::list<CParameter *> m_listCustom;
15018 
15019  public:
15021  inline std::list<CParameter *>::iterator
15023  {
15024  return m_listCustom.begin();
15025  }
15026 
15028  inline std::list<CParameter *>::iterator
15029  endCustom (void)
15030  {
15031  return m_listCustom.end();
15032  }
15033 
15035  inline void
15037  {
15038  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15039  }
15040 
15042  inline int
15044  {
15045  return (int) (m_listCustom.size());
15046  }
15047 
15048  EResultCode
15050  addCustom (
15051  CParameter * pValue);
15052 
15053 
15054 };
15055 
15056 
15087 class CEPCData : public CParameter
15088 {
15089  public:
15090  CEPCData (void);
15091  ~CEPCData (void);
15092 
15095 
15096  static const CFieldDescriptor * const
15097  s_apFieldDescriptorTable[];
15098 
15099  static const CTypeDescriptor
15100  s_typeDescriptor;
15101 
15102  void
15103  decodeFields (
15104  CDecoderStream * pDecoderStream);
15105 
15106  void
15107  assimilateSubParameters (
15108  CErrorDetails * pError);
15109 
15110  void
15111  encode (
15112  CEncoderStream * pEncoderStream) const;
15113 
15114 
15115 
15116  static CElement *
15117  s_construct (void);
15118 
15119  static void
15120  s_decodeFields (
15121  CDecoderStream * pDecoderStream,
15122  CElement * pElement);
15124 
15125 
15126  protected:
15127  llrp_u1v_t m_EPC;
15128 
15131  public:
15132  static const CFieldDescriptor
15133  s_fdEPC;
15135 
15137  inline llrp_u1v_t
15138  getEPC (void)
15139  {
15140  return m_EPC;
15141  }
15142 
15144  inline void
15146  llrp_u1v_t value)
15147  {
15148  m_EPC = value;
15149  }
15150 
15151 
15152 
15153 };
15154 
15155 
15186 class CEPC_96 : public CParameter
15187 {
15188  public:
15189  CEPC_96 (void);
15190  ~CEPC_96 (void);
15191 
15194 
15195  static const CFieldDescriptor * const
15196  s_apFieldDescriptorTable[];
15197 
15198  static const CTypeDescriptor
15199  s_typeDescriptor;
15200 
15201  void
15202  decodeFields (
15203  CDecoderStream * pDecoderStream);
15204 
15205  void
15206  assimilateSubParameters (
15207  CErrorDetails * pError);
15208 
15209  void
15210  encode (
15211  CEncoderStream * pEncoderStream) const;
15212 
15213 
15214 
15215  static CElement *
15216  s_construct (void);
15217 
15218  static void
15219  s_decodeFields (
15220  CDecoderStream * pDecoderStream,
15221  CElement * pElement);
15223 
15224 
15225  protected:
15226  llrp_u96_t m_EPC;
15227 
15230  public:
15231  static const CFieldDescriptor
15232  s_fdEPC;
15234 
15236  inline llrp_u96_t
15237  getEPC (void)
15238  {
15239  return m_EPC;
15240  }
15241 
15243  inline void
15245  llrp_u96_t value)
15246  {
15247  m_EPC = value;
15248  }
15249 
15250 
15251 
15252 };
15253 
15254 
15285 class CROSpecID : public CParameter
15286 {
15287  public:
15288  CROSpecID (void);
15289  ~CROSpecID (void);
15290 
15293 
15294  static const CFieldDescriptor * const
15295  s_apFieldDescriptorTable[];
15296 
15297  static const CTypeDescriptor
15298  s_typeDescriptor;
15299 
15300  void
15301  decodeFields (
15302  CDecoderStream * pDecoderStream);
15303 
15304  void
15305  assimilateSubParameters (
15306  CErrorDetails * pError);
15307 
15308  void
15309  encode (
15310  CEncoderStream * pEncoderStream) const;
15311 
15312 
15313 
15314  static CElement *
15315  s_construct (void);
15316 
15317  static void
15318  s_decodeFields (
15319  CDecoderStream * pDecoderStream,
15320  CElement * pElement);
15322 
15323 
15324  protected:
15325  llrp_u32_t m_ROSpecID;
15326 
15329  public:
15330  static const CFieldDescriptor
15331  s_fdROSpecID;
15333 
15335  inline llrp_u32_t
15337  {
15338  return m_ROSpecID;
15339  }
15340 
15342  inline void
15344  llrp_u32_t value)
15345  {
15346  m_ROSpecID = value;
15347  }
15348 
15349 
15350 
15351 };
15352 
15353 
15384 class CSpecIndex : public CParameter
15385 {
15386  public:
15387  CSpecIndex (void);
15388  ~CSpecIndex (void);
15389 
15392 
15393  static const CFieldDescriptor * const
15394  s_apFieldDescriptorTable[];
15395 
15396  static const CTypeDescriptor
15397  s_typeDescriptor;
15398 
15399  void
15400  decodeFields (
15401  CDecoderStream * pDecoderStream);
15402 
15403  void
15404  assimilateSubParameters (
15405  CErrorDetails * pError);
15406 
15407  void
15408  encode (
15409  CEncoderStream * pEncoderStream) const;
15410 
15411 
15412 
15413  static CElement *
15414  s_construct (void);
15415 
15416  static void
15417  s_decodeFields (
15418  CDecoderStream * pDecoderStream,
15419  CElement * pElement);
15421 
15422 
15423  protected:
15424  llrp_u16_t m_SpecIndex;
15425 
15428  public:
15429  static const CFieldDescriptor
15430  s_fdSpecIndex;
15432 
15434  inline llrp_u16_t
15436  {
15437  return m_SpecIndex;
15438  }
15439 
15441  inline void
15443  llrp_u16_t value)
15444  {
15445  m_SpecIndex = value;
15446  }
15447 
15448 
15449 
15450 };
15451 
15452 
15483 class CInventoryParameterSpecID : public CParameter
15484 {
15485  public:
15487  ~CInventoryParameterSpecID (void);
15488 
15491 
15492  static const CFieldDescriptor * const
15493  s_apFieldDescriptorTable[];
15494 
15495  static const CTypeDescriptor
15496  s_typeDescriptor;
15497 
15498  void
15499  decodeFields (
15500  CDecoderStream * pDecoderStream);
15501 
15502  void
15503  assimilateSubParameters (
15504  CErrorDetails * pError);
15505 
15506  void
15507  encode (
15508  CEncoderStream * pEncoderStream) const;
15509 
15510 
15511 
15512  static CElement *
15513  s_construct (void);
15514 
15515  static void
15516  s_decodeFields (
15517  CDecoderStream * pDecoderStream,
15518  CElement * pElement);
15520 
15521 
15522  protected:
15523  llrp_u16_t m_InventoryParameterSpecID;
15524 
15527  public:
15528  static const CFieldDescriptor
15529  s_fdInventoryParameterSpecID;
15531 
15533  inline llrp_u16_t
15535  {
15536  return m_InventoryParameterSpecID;
15537  }
15538 
15540  inline void
15542  llrp_u16_t value)
15543  {
15544  m_InventoryParameterSpecID = value;
15545  }
15546 
15547 
15548 
15549 };
15550 
15551 
15582 class CAntennaID : public CParameter
15583 {
15584  public:
15585  CAntennaID (void);
15586  ~CAntennaID (void);
15587 
15590 
15591  static const CFieldDescriptor * const
15592  s_apFieldDescriptorTable[];
15593 
15594  static const CTypeDescriptor
15595  s_typeDescriptor;
15596 
15597  void
15598  decodeFields (
15599  CDecoderStream * pDecoderStream);
15600 
15601  void
15602  assimilateSubParameters (
15603  CErrorDetails * pError);
15604 
15605  void
15606  encode (
15607  CEncoderStream * pEncoderStream) const;
15608 
15609 
15610 
15611  static CElement *
15612  s_construct (void);
15613 
15614  static void
15615  s_decodeFields (
15616  CDecoderStream * pDecoderStream,
15617  CElement * pElement);
15619 
15620 
15621  protected:
15622  llrp_u16_t m_AntennaID;
15623 
15626  public:
15627  static const CFieldDescriptor
15628  s_fdAntennaID;
15630 
15632  inline llrp_u16_t
15634  {
15635  return m_AntennaID;
15636  }
15637 
15639  inline void
15641  llrp_u16_t value)
15642  {
15643  m_AntennaID = value;
15644  }
15645 
15646 
15647 
15648 };
15649 
15650 
15684 class CPeakRSSI : public CParameter
15685 {
15686  public:
15687  CPeakRSSI (void);
15688  ~CPeakRSSI (void);
15689 
15692 
15693  static const CFieldDescriptor * const
15694  s_apFieldDescriptorTable[];
15695 
15696  static const CTypeDescriptor
15697  s_typeDescriptor;
15698 
15699  void
15700  decodeFields (
15701  CDecoderStream * pDecoderStream);
15702 
15703  void
15704  assimilateSubParameters (
15705  CErrorDetails * pError);
15706 
15707  void
15708  encode (
15709  CEncoderStream * pEncoderStream) const;
15710 
15711 
15712 
15713  static CElement *
15714  s_construct (void);
15715 
15716  static void
15717  s_decodeFields (
15718  CDecoderStream * pDecoderStream,
15719  CElement * pElement);
15721 
15722 
15723  protected:
15724  llrp_s8_t m_PeakRSSI;
15725 
15728  public:
15729  static const CFieldDescriptor
15730  s_fdPeakRSSI;
15732 
15734  inline llrp_s8_t
15736  {
15737  return m_PeakRSSI;
15738  }
15739 
15741  inline void
15743  llrp_s8_t value)
15744  {
15745  m_PeakRSSI = value;
15746  }
15747 
15748 
15749 
15750 };
15751 
15752 
15783 class CChannelIndex : public CParameter
15784 {
15785  public:
15786  CChannelIndex (void);
15787  ~CChannelIndex (void);
15788 
15791 
15792  static const CFieldDescriptor * const
15793  s_apFieldDescriptorTable[];
15794 
15795  static const CTypeDescriptor
15796  s_typeDescriptor;
15797 
15798  void
15799  decodeFields (
15800  CDecoderStream * pDecoderStream);
15801 
15802  void
15803  assimilateSubParameters (
15804  CErrorDetails * pError);
15805 
15806  void
15807  encode (
15808  CEncoderStream * pEncoderStream) const;
15809 
15810 
15811 
15812  static CElement *
15813  s_construct (void);
15814 
15815  static void
15816  s_decodeFields (
15817  CDecoderStream * pDecoderStream,
15818  CElement * pElement);
15820 
15821 
15822  protected:
15823  llrp_u16_t m_ChannelIndex;
15824 
15827  public:
15828  static const CFieldDescriptor
15829  s_fdChannelIndex;
15831 
15833  inline llrp_u16_t
15835  {
15836  return m_ChannelIndex;
15837  }
15838 
15840  inline void
15842  llrp_u16_t value)
15843  {
15844  m_ChannelIndex = value;
15845  }
15846 
15847 
15848 
15849 };
15850 
15851 
15890 class CFirstSeenTimestampUTC : public CParameter
15891 {
15892  public:
15893  CFirstSeenTimestampUTC (void);
15894  ~CFirstSeenTimestampUTC (void);
15895 
15898 
15899  static const CFieldDescriptor * const
15900  s_apFieldDescriptorTable[];
15901 
15902  static const CTypeDescriptor
15903  s_typeDescriptor;
15904 
15905  void
15906  decodeFields (
15907  CDecoderStream * pDecoderStream);
15908 
15909  void
15910  assimilateSubParameters (
15911  CErrorDetails * pError);
15912 
15913  void
15914  encode (
15915  CEncoderStream * pEncoderStream) const;
15916 
15917 
15918 
15919  static CElement *
15920  s_construct (void);
15921 
15922  static void
15923  s_decodeFields (
15924  CDecoderStream * pDecoderStream,
15925  CElement * pElement);
15927 
15928 
15929  protected:
15930  llrp_u64_t m_Microseconds;
15931 
15934  public:
15935  static const CFieldDescriptor
15936  s_fdMicroseconds;
15938 
15940  inline llrp_u64_t
15942  {
15943  return m_Microseconds;
15944  }
15945 
15947  inline void
15949  llrp_u64_t value)
15950  {
15951  m_Microseconds = value;
15952  }
15953 
15954 
15955 
15956 };
15957 
15958 
15996 class CFirstSeenTimestampUptime : public CParameter
15997 {
15998  public:
16000  ~CFirstSeenTimestampUptime (void);
16001 
16004 
16005  static const CFieldDescriptor * const
16006  s_apFieldDescriptorTable[];
16007 
16008  static const CTypeDescriptor
16009  s_typeDescriptor;
16010 
16011  void
16012  decodeFields (
16013  CDecoderStream * pDecoderStream);
16014 
16015  void
16016  assimilateSubParameters (
16017  CErrorDetails * pError);
16018 
16019  void
16020  encode (
16021  CEncoderStream * pEncoderStream) const;
16022 
16023 
16024 
16025  static CElement *
16026  s_construct (void);
16027 
16028  static void
16029  s_decodeFields (
16030  CDecoderStream * pDecoderStream,
16031  CElement * pElement);
16033 
16034 
16035  protected:
16036  llrp_u64_t m_Microseconds;
16037 
16040  public:
16041  static const CFieldDescriptor
16042  s_fdMicroseconds;
16044 
16046  inline llrp_u64_t
16048  {
16049  return m_Microseconds;
16050  }
16051 
16053  inline void
16055  llrp_u64_t value)
16056  {
16057  m_Microseconds = value;
16058  }
16059 
16060 
16061 
16062 };
16063 
16064 
16098 class CLastSeenTimestampUTC : public CParameter
16099 {
16100  public:
16101  CLastSeenTimestampUTC (void);
16102  ~CLastSeenTimestampUTC (void);
16103 
16106 
16107  static const CFieldDescriptor * const
16108  s_apFieldDescriptorTable[];
16109 
16110  static const CTypeDescriptor
16111  s_typeDescriptor;
16112 
16113  void
16114  decodeFields (
16115  CDecoderStream * pDecoderStream);
16116 
16117  void
16118  assimilateSubParameters (
16119  CErrorDetails * pError);
16120 
16121  void
16122  encode (
16123  CEncoderStream * pEncoderStream) const;
16124 
16125 
16126 
16127  static CElement *
16128  s_construct (void);
16129 
16130  static void
16131  s_decodeFields (
16132  CDecoderStream * pDecoderStream,
16133  CElement * pElement);
16135 
16136 
16137  protected:
16138  llrp_u64_t m_Microseconds;
16139 
16142  public:
16143  static const CFieldDescriptor
16144  s_fdMicroseconds;
16146 
16148  inline llrp_u64_t
16150  {
16151  return m_Microseconds;
16152  }
16153 
16155  inline void
16157  llrp_u64_t value)
16158  {
16159  m_Microseconds = value;
16160  }
16161 
16162 
16163 
16164 };
16165 
16166 
16200 class CLastSeenTimestampUptime : public CParameter
16201 {
16202  public:
16203  CLastSeenTimestampUptime (void);
16204  ~CLastSeenTimestampUptime (void);
16205 
16208 
16209  static const CFieldDescriptor * const
16210  s_apFieldDescriptorTable[];
16211 
16212  static const CTypeDescriptor
16213  s_typeDescriptor;
16214 
16215  void
16216  decodeFields (
16217  CDecoderStream * pDecoderStream);
16218 
16219  void
16220  assimilateSubParameters (
16221  CErrorDetails * pError);
16222 
16223  void
16224  encode (
16225  CEncoderStream * pEncoderStream) const;
16226 
16227 
16228 
16229  static CElement *
16230  s_construct (void);
16231 
16232  static void
16233  s_decodeFields (
16234  CDecoderStream * pDecoderStream,
16235  CElement * pElement);
16237 
16238 
16239  protected:
16240  llrp_u64_t m_Microseconds;
16241 
16244  public:
16245  static const CFieldDescriptor
16246  s_fdMicroseconds;
16248 
16250  inline llrp_u64_t
16252  {
16253  return m_Microseconds;
16254  }
16255 
16257  inline void
16259  llrp_u64_t value)
16260  {
16261  m_Microseconds = value;
16262  }
16263 
16264 
16265 
16266 };
16267 
16268 
16301 class CTagSeenCount : public CParameter
16302 {
16303  public:
16304  CTagSeenCount (void);
16305  ~CTagSeenCount (void);
16306 
16309 
16310  static const CFieldDescriptor * const
16311  s_apFieldDescriptorTable[];
16312 
16313  static const CTypeDescriptor
16314  s_typeDescriptor;
16315 
16316  void
16317  decodeFields (
16318  CDecoderStream * pDecoderStream);
16319 
16320  void
16321  assimilateSubParameters (
16322  CErrorDetails * pError);
16323 
16324  void
16325  encode (
16326  CEncoderStream * pEncoderStream) const;
16327 
16328 
16329 
16330  static CElement *
16331  s_construct (void);
16332 
16333  static void
16334  s_decodeFields (
16335  CDecoderStream * pDecoderStream,
16336  CElement * pElement);
16338 
16339 
16340  protected:
16341  llrp_u16_t m_TagCount;
16342 
16345  public:
16346  static const CFieldDescriptor
16347  s_fdTagCount;
16349 
16351  inline llrp_u16_t
16353  {
16354  return m_TagCount;
16355  }
16356 
16358  inline void
16360  llrp_u16_t value)
16361  {
16362  m_TagCount = value;
16363  }
16364 
16365 
16366 
16367 };
16368 
16369 
16397 class CClientRequestOpSpecResult : public CParameter
16398 {
16399  public:
16402 
16405 
16406  static const CFieldDescriptor * const
16407  s_apFieldDescriptorTable[];
16408 
16409  static const CTypeDescriptor
16410  s_typeDescriptor;
16411 
16412  void
16413  decodeFields (
16414  CDecoderStream * pDecoderStream);
16415 
16416  void
16417  assimilateSubParameters (
16418  CErrorDetails * pError);
16419 
16420  void
16421  encode (
16422  CEncoderStream * pEncoderStream) const;
16423 
16424 
16425 
16426  static CElement *
16427  s_construct (void);
16428 
16429  static void
16430  s_decodeFields (
16431  CDecoderStream * pDecoderStream,
16432  CElement * pElement);
16434 
16435 
16436  protected:
16437  llrp_u16_t m_OpSpecID;
16438 
16441  public:
16442  static const CFieldDescriptor
16443  s_fdOpSpecID;
16445 
16447  inline llrp_u16_t
16449  {
16450  return m_OpSpecID;
16451  }
16452 
16454  inline void
16456  llrp_u16_t value)
16457  {
16458  m_OpSpecID = value;
16459  }
16460 
16461 
16462 
16463 };
16464 
16465 
16496 class CAccessSpecID : public CParameter
16497 {
16498  public:
16499  CAccessSpecID (void);
16500  ~CAccessSpecID (void);
16501 
16504 
16505  static const CFieldDescriptor * const
16506  s_apFieldDescriptorTable[];
16507 
16508  static const CTypeDescriptor
16509  s_typeDescriptor;
16510 
16511  void
16512  decodeFields (
16513  CDecoderStream * pDecoderStream);
16514 
16515  void
16516  assimilateSubParameters (
16517  CErrorDetails * pError);
16518 
16519  void
16520  encode (
16521  CEncoderStream * pEncoderStream) const;
16522 
16523 
16524 
16525  static CElement *
16526  s_construct (void);
16527 
16528  static void
16529  s_decodeFields (
16530  CDecoderStream * pDecoderStream,
16531  CElement * pElement);
16533 
16534 
16535  protected:
16536  llrp_u32_t m_AccessSpecID;
16537 
16540  public:
16541  static const CFieldDescriptor
16542  s_fdAccessSpecID;
16544 
16546  inline llrp_u32_t
16548  {
16549  return m_AccessSpecID;
16550  }
16551 
16553  inline void
16555  llrp_u32_t value)
16556  {
16557  m_AccessSpecID = value;
16558  }
16559 
16560 
16561 
16562 };
16563 
16564 
16598 class CRFSurveyReportData : public CParameter
16599 {
16600  public:
16601  CRFSurveyReportData (void);
16602  ~CRFSurveyReportData (void);
16603 
16606 
16607  static const CFieldDescriptor * const
16608  s_apFieldDescriptorTable[];
16609 
16610  static const CTypeDescriptor
16611  s_typeDescriptor;
16612 
16613  void
16614  decodeFields (
16615  CDecoderStream * pDecoderStream);
16616 
16617  void
16618  assimilateSubParameters (
16619  CErrorDetails * pError);
16620 
16621  void
16622  encode (
16623  CEncoderStream * pEncoderStream) const;
16624 
16625 
16626 
16627  static CElement *
16628  s_construct (void);
16629 
16630  static void
16631  s_decodeFields (
16632  CDecoderStream * pDecoderStream,
16633  CElement * pElement);
16635 
16636 
16637 
16638  protected:
16639  CROSpecID * m_pROSpecID;
16640 
16641  public:
16643  inline CROSpecID *
16645  {
16646  return m_pROSpecID;
16647  }
16648 
16650  EResultCode
16651  setROSpecID (
16652  CROSpecID * pValue);
16653 
16654 
16655  protected:
16656  CSpecIndex * m_pSpecIndex;
16657 
16658  public:
16660  inline CSpecIndex *
16662  {
16663  return m_pSpecIndex;
16664  }
16665 
16667  EResultCode
16668  setSpecIndex (
16669  CSpecIndex * pValue);
16670 
16671 
16672  protected:
16673  std::list<CFrequencyRSSILevelEntry *> m_listFrequencyRSSILevelEntry;
16674 
16675  public:
16677  inline std::list<CFrequencyRSSILevelEntry *>::iterator
16679  {
16680  return m_listFrequencyRSSILevelEntry.begin();
16681  }
16682 
16684  inline std::list<CFrequencyRSSILevelEntry *>::iterator
16686  {
16687  return m_listFrequencyRSSILevelEntry.end();
16688  }
16689 
16691  inline void
16693  {
16694  clearSubParameterList ((tListOfParameters *) &m_listFrequencyRSSILevelEntry);
16695  }
16696 
16698  inline int
16700  {
16701  return (int) (m_listFrequencyRSSILevelEntry.size());
16702  }
16703 
16704  EResultCode
16706  addFrequencyRSSILevelEntry (
16707  CFrequencyRSSILevelEntry * pValue);
16708 
16709 
16710  protected:
16711  std::list<CParameter *> m_listCustom;
16712 
16713  public:
16715  inline std::list<CParameter *>::iterator
16717  {
16718  return m_listCustom.begin();
16719  }
16720 
16722  inline std::list<CParameter *>::iterator
16723  endCustom (void)
16724  {
16725  return m_listCustom.end();
16726  }
16727 
16729  inline void
16731  {
16732  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16733  }
16734 
16736  inline int
16738  {
16739  return (int) (m_listCustom.size());
16740  }
16741 
16742  EResultCode
16744  addCustom (
16745  CParameter * pValue);
16746 
16747 
16748 };
16749 
16750 
16809 class CFrequencyRSSILevelEntry : public CParameter
16810 {
16811  public:
16812  CFrequencyRSSILevelEntry (void);
16813  ~CFrequencyRSSILevelEntry (void);
16814 
16817 
16818  static const CFieldDescriptor * const
16819  s_apFieldDescriptorTable[];
16820 
16821  static const CTypeDescriptor
16822  s_typeDescriptor;
16823 
16824  void
16825  decodeFields (
16826  CDecoderStream * pDecoderStream);
16827 
16828  void
16829  assimilateSubParameters (
16830  CErrorDetails * pError);
16831 
16832  void
16833  encode (
16834  CEncoderStream * pEncoderStream) const;
16835 
16836 
16837 
16838  static CElement *
16839  s_construct (void);
16840 
16841  static void
16842  s_decodeFields (
16843  CDecoderStream * pDecoderStream,
16844  CElement * pElement);
16846 
16847 
16848  protected:
16849  llrp_u32_t m_Frequency;
16850 
16853  public:
16854  static const CFieldDescriptor
16855  s_fdFrequency;
16857 
16859  inline llrp_u32_t
16861  {
16862  return m_Frequency;
16863  }
16864 
16866  inline void
16868  llrp_u32_t value)
16869  {
16870  m_Frequency = value;
16871  }
16872 
16873 
16874  protected:
16875  llrp_u32_t m_Bandwidth;
16876 
16879  public:
16880  static const CFieldDescriptor
16881  s_fdBandwidth;
16883 
16885  inline llrp_u32_t
16887  {
16888  return m_Bandwidth;
16889  }
16890 
16892  inline void
16894  llrp_u32_t value)
16895  {
16896  m_Bandwidth = value;
16897  }
16898 
16899 
16900  protected:
16901  llrp_s8_t m_AverageRSSI;
16902 
16905  public:
16906  static const CFieldDescriptor
16907  s_fdAverageRSSI;
16909 
16911  inline llrp_s8_t
16913  {
16914  return m_AverageRSSI;
16915  }
16916 
16918  inline void
16920  llrp_s8_t value)
16921  {
16922  m_AverageRSSI = value;
16923  }
16924 
16925 
16926  protected:
16927  llrp_s8_t m_PeakRSSI;
16928 
16931  public:
16932  static const CFieldDescriptor
16933  s_fdPeakRSSI;
16935 
16937  inline llrp_s8_t
16939  {
16940  return m_PeakRSSI;
16941  }
16942 
16944  inline void
16946  llrp_s8_t value)
16947  {
16948  m_PeakRSSI = value;
16949  }
16950 
16951 
16952 
16953  protected:
16954  CParameter * m_pTimestamp;
16955 
16956  public:
16958  inline CParameter *
16960  {
16961  return m_pTimestamp;
16962  }
16963 
16965  EResultCode
16966  setTimestamp (
16967  CParameter * pValue);
16968 
16969 
16970 };
16971 
16972 
17003 class CReaderEventNotificationSpec : public CParameter
17004 {
17005  public:
17008 
17011 
17012  static const CFieldDescriptor * const
17013  s_apFieldDescriptorTable[];
17014 
17015  static const CTypeDescriptor
17016  s_typeDescriptor;
17017 
17018  void
17019  decodeFields (
17020  CDecoderStream * pDecoderStream);
17021 
17022  void
17023  assimilateSubParameters (
17024  CErrorDetails * pError);
17025 
17026  void
17027  encode (
17028  CEncoderStream * pEncoderStream) const;
17029 
17030 
17031 
17032  static CElement *
17033  s_construct (void);
17034 
17035  static void
17036  s_decodeFields (
17037  CDecoderStream * pDecoderStream,
17038  CElement * pElement);
17040 
17041 
17042 
17043  protected:
17044  std::list<CEventNotificationState *> m_listEventNotificationState;
17045 
17046  public:
17048  inline std::list<CEventNotificationState *>::iterator
17050  {
17051  return m_listEventNotificationState.begin();
17052  }
17053 
17055  inline std::list<CEventNotificationState *>::iterator
17057  {
17058  return m_listEventNotificationState.end();
17059  }
17060 
17062  inline void
17064  {
17065  clearSubParameterList ((tListOfParameters *) &m_listEventNotificationState);
17066  }
17067 
17069  inline int
17071  {
17072  return (int) (m_listEventNotificationState.size());
17073  }
17074 
17075  EResultCode
17077  addEventNotificationState (
17078  CEventNotificationState * pValue);
17079 
17080 
17081 };
17082 
17083 
17116 class CEventNotificationState : public CParameter
17117 {
17118  public:
17119  CEventNotificationState (void);
17120  ~CEventNotificationState (void);
17121 
17124 
17125  static const CFieldDescriptor * const
17126  s_apFieldDescriptorTable[];
17127 
17128  static const CTypeDescriptor
17129  s_typeDescriptor;
17130 
17131  void
17132  decodeFields (
17133  CDecoderStream * pDecoderStream);
17134 
17135  void
17136  assimilateSubParameters (
17137  CErrorDetails * pError);
17138 
17139  void
17140  encode (
17141  CEncoderStream * pEncoderStream) const;
17142 
17143 
17144 
17145  static CElement *
17146  s_construct (void);
17147 
17148  static void
17149  s_decodeFields (
17150  CDecoderStream * pDecoderStream,
17151  CElement * pElement);
17153 
17154 
17155  protected:
17156  ENotificationEventType m_eEventType;
17157 
17160  public:
17161  static const CFieldDescriptor
17162  s_fdEventType;
17164 
17166  inline ENotificationEventType
17168  {
17169  return m_eEventType;
17170  }
17171 
17173  inline void
17175  ENotificationEventType value)
17176  {
17177  m_eEventType = value;
17178  }
17179 
17180 
17181  protected:
17182  llrp_u1_t m_NotificationState;
17183 
17186  public:
17187  static const CFieldDescriptor
17188  s_fdNotificationState;
17190 
17192  inline llrp_u1_t
17194  {
17195  return m_NotificationState;
17196  }
17197 
17199  inline void
17201  llrp_u1_t value)
17202  {
17203  m_NotificationState = value;
17204  }
17205 
17206 
17207 
17208 };
17209 
17210 
17320 class CReaderEventNotificationData : public CParameter
17321 {
17322  public:
17325 
17328 
17329  static const CFieldDescriptor * const
17330  s_apFieldDescriptorTable[];
17331 
17332  static const CTypeDescriptor
17333  s_typeDescriptor;
17334 
17335  void
17336  decodeFields (
17337  CDecoderStream * pDecoderStream);
17338 
17339  void
17340  assimilateSubParameters (
17341  CErrorDetails * pError);
17342 
17343  void
17344  encode (
17345  CEncoderStream * pEncoderStream) const;
17346 
17347 
17348 
17349  static CElement *
17350  s_construct (void);
17351 
17352  static void
17353  s_decodeFields (
17354  CDecoderStream * pDecoderStream,
17355  CElement * pElement);
17357 
17358 
17359 
17360  protected:
17361  CParameter * m_pTimestamp;
17362 
17363  public:
17365  inline CParameter *
17367  {
17368  return m_pTimestamp;
17369  }
17370 
17372  EResultCode
17373  setTimestamp (
17374  CParameter * pValue);
17375 
17376 
17377  protected:
17378  CHoppingEvent * m_pHoppingEvent;
17379 
17380  public:
17382  inline CHoppingEvent *
17384  {
17385  return m_pHoppingEvent;
17386  }
17387 
17389  EResultCode
17390  setHoppingEvent (
17391  CHoppingEvent * pValue);
17392 
17393 
17394  protected:
17395  CGPIEvent * m_pGPIEvent;
17396 
17397  public:
17399  inline CGPIEvent *
17401  {
17402  return m_pGPIEvent;
17403  }
17404 
17406  EResultCode
17407  setGPIEvent (
17408  CGPIEvent * pValue);
17409 
17410 
17411  protected:
17412  CROSpecEvent * m_pROSpecEvent;
17413 
17414  public:
17416  inline CROSpecEvent *
17418  {
17419  return m_pROSpecEvent;
17420  }
17421 
17423  EResultCode
17424  setROSpecEvent (
17425  CROSpecEvent * pValue);
17426 
17427 
17428  protected:
17429  CReportBufferLevelWarningEvent * m_pReportBufferLevelWarningEvent;
17430 
17431  public:
17435  {
17436  return m_pReportBufferLevelWarningEvent;
17437  }
17438 
17440  EResultCode
17441  setReportBufferLevelWarningEvent (
17443 
17444 
17445  protected:
17446  CReportBufferOverflowErrorEvent * m_pReportBufferOverflowErrorEvent;
17447 
17448  public:
17452  {
17453  return m_pReportBufferOverflowErrorEvent;
17454  }
17455 
17457  EResultCode
17458  setReportBufferOverflowErrorEvent (
17460 
17461 
17462  protected:
17463  CReaderExceptionEvent * m_pReaderExceptionEvent;
17464 
17465  public:
17467  inline CReaderExceptionEvent *
17469  {
17470  return m_pReaderExceptionEvent;
17471  }
17472 
17474  EResultCode
17475  setReaderExceptionEvent (
17476  CReaderExceptionEvent * pValue);
17477 
17478 
17479  protected:
17480  CRFSurveyEvent * m_pRFSurveyEvent;
17481 
17482  public:
17484  inline CRFSurveyEvent *
17486  {
17487  return m_pRFSurveyEvent;
17488  }
17489 
17491  EResultCode
17492  setRFSurveyEvent (
17493  CRFSurveyEvent * pValue);
17494 
17495 
17496  protected:
17497  CAISpecEvent * m_pAISpecEvent;
17498 
17499  public:
17501  inline CAISpecEvent *
17503  {
17504  return m_pAISpecEvent;
17505  }
17506 
17508  EResultCode
17509  setAISpecEvent (
17510  CAISpecEvent * pValue);
17511 
17512 
17513  protected:
17514  CAntennaEvent * m_pAntennaEvent;
17515 
17516  public:
17518  inline CAntennaEvent *
17520  {
17521  return m_pAntennaEvent;
17522  }
17523 
17525  EResultCode
17526  setAntennaEvent (
17527  CAntennaEvent * pValue);
17528 
17529 
17530  protected:
17531  CConnectionAttemptEvent * m_pConnectionAttemptEvent;
17532 
17533  public:
17535  inline CConnectionAttemptEvent *
17537  {
17538  return m_pConnectionAttemptEvent;
17539  }
17540 
17542  EResultCode
17543  setConnectionAttemptEvent (
17544  CConnectionAttemptEvent * pValue);
17545 
17546 
17547  protected:
17548  CConnectionCloseEvent * m_pConnectionCloseEvent;
17549 
17550  public:
17552  inline CConnectionCloseEvent *
17554  {
17555  return m_pConnectionCloseEvent;
17556  }
17557 
17559  EResultCode
17560  setConnectionCloseEvent (
17561  CConnectionCloseEvent * pValue);
17562 
17563 
17564  protected:
17565  std::list<CParameter *> m_listCustom;
17566 
17567  public:
17569  inline std::list<CParameter *>::iterator
17571  {
17572  return m_listCustom.begin();
17573  }
17574 
17576  inline std::list<CParameter *>::iterator
17577  endCustom (void)
17578  {
17579  return m_listCustom.end();
17580  }
17581 
17583  inline void
17585  {
17586  clearSubParameterList ((tListOfParameters *) &m_listCustom);
17587  }
17588 
17590  inline int
17592  {
17593  return (int) (m_listCustom.size());
17594  }
17595 
17596  EResultCode
17598  addCustom (
17599  CParameter * pValue);
17600 
17601 
17602 };
17603 
17604 
17639 class CHoppingEvent : public CParameter
17640 {
17641  public:
17642  CHoppingEvent (void);
17643  ~CHoppingEvent (void);
17644 
17647 
17648  static const CFieldDescriptor * const
17649  s_apFieldDescriptorTable[];
17650 
17651  static const CTypeDescriptor
17652  s_typeDescriptor;
17653 
17654  void
17655  decodeFields (
17656  CDecoderStream * pDecoderStream);
17657 
17658  void
17659  assimilateSubParameters (
17660  CErrorDetails * pError);
17661 
17662  void
17663  encode (
17664  CEncoderStream * pEncoderStream) const;
17665 
17666 
17667 
17668  static CElement *
17669  s_construct (void);
17670 
17671  static void
17672  s_decodeFields (
17673  CDecoderStream * pDecoderStream,
17674  CElement * pElement);
17676 
17677 
17678  protected:
17679  llrp_u16_t m_HopTableID;
17680 
17683  public:
17684  static const CFieldDescriptor
17685  s_fdHopTableID;
17687 
17689  inline llrp_u16_t
17691  {
17692  return m_HopTableID;
17693  }
17694 
17696  inline void
17698  llrp_u16_t value)
17699  {
17700  m_HopTableID = value;
17701  }
17702 
17703 
17704  protected:
17705  llrp_u16_t m_NextChannelIndex;
17706 
17709  public:
17710  static const CFieldDescriptor
17711  s_fdNextChannelIndex;
17713 
17715  inline llrp_u16_t
17717  {
17718  return m_NextChannelIndex;
17719  }
17720 
17722  inline void
17724  llrp_u16_t value)
17725  {
17726  m_NextChannelIndex = value;
17727  }
17728 
17729 
17730 
17731 };
17732 
17733 
17766 class CGPIEvent : public CParameter
17767 {
17768  public:
17769  CGPIEvent (void);
17770  ~CGPIEvent (void);
17771 
17774 
17775  static const CFieldDescriptor * const
17776  s_apFieldDescriptorTable[];
17777 
17778  static const CTypeDescriptor
17779  s_typeDescriptor;
17780 
17781  void
17782  decodeFields (
17783  CDecoderStream * pDecoderStream);
17784 
17785  void
17786  assimilateSubParameters (
17787  CErrorDetails * pError);
17788 
17789  void
17790  encode (
17791  CEncoderStream * pEncoderStream) const;
17792 
17793 
17794 
17795  static CElement *
17796  s_construct (void);
17797 
17798  static void
17799  s_decodeFields (
17800  CDecoderStream * pDecoderStream,
17801  CElement * pElement);
17803 
17804 
17805  protected:
17806  llrp_u16_t m_GPIPortNumber;
17807 
17810  public:
17811  static const CFieldDescriptor
17812  s_fdGPIPortNumber;
17814 
17816  inline llrp_u16_t
17818  {
17819  return m_GPIPortNumber;
17820  }
17821 
17823  inline void
17825  llrp_u16_t value)
17826  {
17827  m_GPIPortNumber = value;
17828  }
17829 
17830 
17831  protected:
17832  llrp_u1_t m_GPIEvent;
17833 
17836  public:
17837  static const CFieldDescriptor
17838  s_fdGPIEvent;
17840 
17842  inline llrp_u1_t
17844  {
17845  return m_GPIEvent;
17846  }
17847 
17849  inline void
17851  llrp_u1_t value)
17852  {
17853  m_GPIEvent = value;
17854  }
17855 
17856 
17857 
17858 };
17859 
17860 
17896 class CROSpecEvent : public CParameter
17897 {
17898  public:
17899  CROSpecEvent (void);
17900  ~CROSpecEvent (void);
17901 
17904 
17905  static const CFieldDescriptor * const
17906  s_apFieldDescriptorTable[];
17907 
17908  static const CTypeDescriptor
17909  s_typeDescriptor;
17910 
17911  void
17912  decodeFields (
17913  CDecoderStream * pDecoderStream);
17914 
17915  void
17916  assimilateSubParameters (
17917  CErrorDetails * pError);
17918 
17919  void
17920  encode (
17921  CEncoderStream * pEncoderStream) const;
17922 
17923 
17924 
17925  static CElement *
17926  s_construct (void);
17927 
17928  static void
17929  s_decodeFields (
17930  CDecoderStream * pDecoderStream,
17931  CElement * pElement);
17933 
17934 
17935  protected:
17936  EROSpecEventType m_eEventType;
17937 
17940  public:
17941  static const CFieldDescriptor
17942  s_fdEventType;
17944 
17946  inline EROSpecEventType
17948  {
17949  return m_eEventType;
17950  }
17951 
17953  inline void
17955  EROSpecEventType value)
17956  {
17957  m_eEventType = value;
17958  }
17959 
17960 
17961  protected:
17962  llrp_u32_t m_ROSpecID;
17963 
17966  public:
17967  static const CFieldDescriptor
17968  s_fdROSpecID;
17970 
17972  inline llrp_u32_t
17974  {
17975  return m_ROSpecID;
17976  }
17977 
17979  inline void
17981  llrp_u32_t value)
17982  {
17983  m_ROSpecID = value;
17984  }
17985 
17986 
17987  protected:
17988  llrp_u32_t m_PreemptingROSpecID;
17989 
17992  public:
17993  static const CFieldDescriptor
17994  s_fdPreemptingROSpecID;
17996 
17998  inline llrp_u32_t
18000  {
18001  return m_PreemptingROSpecID;
18002  }
18003 
18005  inline void
18007  llrp_u32_t value)
18008  {
18009  m_PreemptingROSpecID = value;
18010  }
18011 
18012 
18013 
18014 };
18015 
18016 
18054 class CReportBufferLevelWarningEvent : public CParameter
18055 {
18056  public:
18059 
18062 
18063  static const CFieldDescriptor * const
18064  s_apFieldDescriptorTable[];
18065 
18066  static const CTypeDescriptor
18067  s_typeDescriptor;
18068 
18069  void
18070  decodeFields (
18071  CDecoderStream * pDecoderStream);
18072 
18073  void
18074  assimilateSubParameters (
18075  CErrorDetails * pError);
18076 
18077  void
18078  encode (
18079  CEncoderStream * pEncoderStream) const;
18080 
18081 
18082 
18083  static CElement *
18084  s_construct (void);
18085 
18086  static void
18087  s_decodeFields (
18088  CDecoderStream * pDecoderStream,
18089  CElement * pElement);
18091 
18092 
18093  protected:
18094  llrp_u8_t m_ReportBufferPercentageFull;
18095 
18098  public:
18099  static const CFieldDescriptor
18100  s_fdReportBufferPercentageFull;
18102 
18104  inline llrp_u8_t
18106  {
18107  return m_ReportBufferPercentageFull;
18108  }
18109 
18111  inline void
18113  llrp_u8_t value)
18114  {
18115  m_ReportBufferPercentageFull = value;
18116  }
18117 
18118 
18119 
18120 };
18121 
18122 
18157 class CReportBufferOverflowErrorEvent : public CParameter
18158 {
18159  public:
18162 
18165 
18166  static const CFieldDescriptor * const
18167  s_apFieldDescriptorTable[];
18168 
18169  static const CTypeDescriptor
18170  s_typeDescriptor;
18171 
18172  void
18173  decodeFields (
18174  CDecoderStream * pDecoderStream);
18175 
18176  void
18177  assimilateSubParameters (
18178  CErrorDetails * pError);
18179 
18180  void
18181  encode (
18182  CEncoderStream * pEncoderStream) const;
18183 
18184 
18185 
18186  static CElement *
18187  s_construct (void);
18188 
18189  static void
18190  s_decodeFields (
18191  CDecoderStream * pDecoderStream,
18192  CElement * pElement);
18194 
18195 
18196 
18197 };
18198 
18199 
18237 class CReaderExceptionEvent : public CParameter
18238 {
18239  public:
18240  CReaderExceptionEvent (void);
18241  ~CReaderExceptionEvent (void);
18242 
18245 
18246  static const CFieldDescriptor * const
18247  s_apFieldDescriptorTable[];
18248 
18249  static const CTypeDescriptor
18250  s_typeDescriptor;
18251 
18252  void
18253  decodeFields (
18254  CDecoderStream * pDecoderStream);
18255 
18256  void
18257  assimilateSubParameters (
18258  CErrorDetails * pError);
18259 
18260  void
18261  encode (
18262  CEncoderStream * pEncoderStream) const;
18263 
18264 
18265 
18266  static CElement *
18267  s_construct (void);
18268 
18269  static void
18270  s_decodeFields (
18271  CDecoderStream * pDecoderStream,
18272  CElement * pElement);
18274 
18275 
18276  protected:
18277  llrp_utf8v_t m_Message;
18278 
18281  public:
18282  static const CFieldDescriptor
18283  s_fdMessage;
18285 
18287  inline llrp_utf8v_t
18288  getMessage (void)
18289  {
18290  return m_Message;
18291  }
18292 
18294  inline void
18296  llrp_utf8v_t value)
18297  {
18298  m_Message = value;
18299  }
18300 
18301 
18302 
18303  protected:
18304  CROSpecID * m_pROSpecID;
18305 
18306  public:
18308  inline CROSpecID *
18310  {
18311  return m_pROSpecID;
18312  }
18313 
18315  EResultCode
18316  setROSpecID (
18317  CROSpecID * pValue);
18318 
18319 
18320  protected:
18321  CSpecIndex * m_pSpecIndex;
18322 
18323  public:
18325  inline CSpecIndex *
18327  {
18328  return m_pSpecIndex;
18329  }
18330 
18332  EResultCode
18333  setSpecIndex (
18334  CSpecIndex * pValue);
18335 
18336 
18337  protected:
18338  CInventoryParameterSpecID * m_pInventoryParameterSpecID;
18339 
18340  public:
18342  inline CInventoryParameterSpecID *
18344  {
18345  return m_pInventoryParameterSpecID;
18346  }
18347 
18349  EResultCode
18350  setInventoryParameterSpecID (
18351  CInventoryParameterSpecID * pValue);
18352 
18353 
18354  protected:
18355  CAntennaID * m_pAntennaID;
18356 
18357  public:
18359  inline CAntennaID *
18361  {
18362  return m_pAntennaID;
18363  }
18364 
18366  EResultCode
18367  setAntennaID (
18368  CAntennaID * pValue);
18369 
18370 
18371  protected:
18372  CAccessSpecID * m_pAccessSpecID;
18373 
18374  public:
18376  inline CAccessSpecID *
18378  {
18379  return m_pAccessSpecID;
18380  }
18381 
18383  EResultCode
18384  setAccessSpecID (
18385  CAccessSpecID * pValue);
18386 
18387 
18388  protected:
18389  COpSpecID * m_pOpSpecID;
18390 
18391  public:
18393  inline COpSpecID *
18395  {
18396  return m_pOpSpecID;
18397  }
18398 
18400  EResultCode
18401  setOpSpecID (
18402  COpSpecID * pValue);
18403 
18404 
18405  protected:
18406  std::list<CParameter *> m_listCustom;
18407 
18408  public:
18410  inline std::list<CParameter *>::iterator
18412  {
18413  return m_listCustom.begin();
18414  }
18415 
18417  inline std::list<CParameter *>::iterator
18418  endCustom (void)
18419  {
18420  return m_listCustom.end();
18421  }
18422 
18424  inline void
18426  {
18427  clearSubParameterList ((tListOfParameters *) &m_listCustom);
18428  }
18429 
18431  inline int
18433  {
18434  return (int) (m_listCustom.size());
18435  }
18436 
18437  EResultCode
18439  addCustom (
18440  CParameter * pValue);
18441 
18442 
18443 };
18444 
18445 
18476 class COpSpecID : public CParameter
18477 {
18478  public:
18479  COpSpecID (void);
18480  ~COpSpecID (void);
18481 
18484 
18485  static const CFieldDescriptor * const
18486  s_apFieldDescriptorTable[];
18487 
18488  static const CTypeDescriptor
18489  s_typeDescriptor;
18490 
18491  void
18492  decodeFields (
18493  CDecoderStream * pDecoderStream);
18494 
18495  void
18496  assimilateSubParameters (
18497  CErrorDetails * pError);
18498 
18499  void
18500  encode (
18501  CEncoderStream * pEncoderStream) const;
18502 
18503 
18504 
18505  static CElement *
18506  s_construct (void);
18507 
18508  static void
18509  s_decodeFields (
18510  CDecoderStream * pDecoderStream,
18511  CElement * pElement);
18513 
18514 
18515  protected:
18516  llrp_u16_t m_OpSpecID;
18517 
18520  public:
18521  static const CFieldDescriptor
18522  s_fdOpSpecID;
18524 
18526  inline llrp_u16_t
18528  {
18529  return m_OpSpecID;
18530  }
18531 
18533  inline void
18535  llrp_u16_t value)
18536  {
18537  m_OpSpecID = value;
18538  }
18539 
18540 
18541 
18542 };
18543 
18544 
18577 class CRFSurveyEvent : public CParameter
18578 {
18579  public:
18580  CRFSurveyEvent (void);
18581  ~CRFSurveyEvent (void);
18582 
18585 
18586  static const CFieldDescriptor * const
18587  s_apFieldDescriptorTable[];
18588 
18589  static const CTypeDescriptor
18590  s_typeDescriptor;
18591 
18592  void
18593  decodeFields (
18594  CDecoderStream * pDecoderStream);
18595 
18596  void
18597  assimilateSubParameters (
18598  CErrorDetails * pError);
18599 
18600  void
18601  encode (
18602  CEncoderStream * pEncoderStream) const;
18603 
18604 
18605 
18606  static CElement *
18607  s_construct (void);
18608 
18609  static void
18610  s_decodeFields (
18611  CDecoderStream * pDecoderStream,
18612  CElement * pElement);
18614 
18615 
18616  protected:
18617  ERFSurveyEventType m_eEventType;
18618 
18621  public:
18622  static const CFieldDescriptor
18623  s_fdEventType;
18625 
18627  inline ERFSurveyEventType
18629  {
18630  return m_eEventType;
18631  }
18632 
18634  inline void
18636  ERFSurveyEventType value)
18637  {
18638  m_eEventType = value;
18639  }
18640 
18641 
18642  protected:
18643  llrp_u32_t m_ROSpecID;
18644 
18647  public:
18648  static const CFieldDescriptor
18649  s_fdROSpecID;
18651 
18653  inline llrp_u32_t
18655  {
18656  return m_ROSpecID;
18657  }
18658 
18660  inline void
18662  llrp_u32_t value)
18663  {
18664  m_ROSpecID = value;
18665  }
18666 
18667 
18668  protected:
18669  llrp_u16_t m_SpecIndex;
18670 
18673  public:
18674  static const CFieldDescriptor
18675  s_fdSpecIndex;
18677 
18679  inline llrp_u16_t
18681  {
18682  return m_SpecIndex;
18683  }
18684 
18686  inline void
18688  llrp_u16_t value)
18689  {
18690  m_SpecIndex = value;
18691  }
18692 
18693 
18694 
18695 };
18696 
18697 
18733 class CAISpecEvent : public CParameter
18734 {
18735  public:
18736  CAISpecEvent (void);
18737  ~CAISpecEvent (void);
18738 
18741 
18742  static const CFieldDescriptor * const
18743  s_apFieldDescriptorTable[];
18744 
18745  static const CTypeDescriptor
18746  s_typeDescriptor;
18747 
18748  void
18749  decodeFields (
18750  CDecoderStream * pDecoderStream);
18751 
18752  void
18753  assimilateSubParameters (
18754  CErrorDetails * pError);
18755 
18756  void
18757  encode (
18758  CEncoderStream * pEncoderStream) const;
18759 
18760 
18761 
18762  static CElement *
18763  s_construct (void);
18764 
18765  static void
18766  s_decodeFields (
18767  CDecoderStream * pDecoderStream,
18768  CElement * pElement);
18770 
18771 
18772  protected:
18773  EAISpecEventType m_eEventType;
18774 
18777  public:
18778  static const CFieldDescriptor
18779  s_fdEventType;
18781 
18783  inline EAISpecEventType
18785  {
18786  return m_eEventType;
18787  }
18788 
18790  inline void
18792  EAISpecEventType value)
18793  {
18794  m_eEventType = value;
18795  }
18796 
18797 
18798  protected:
18799  llrp_u32_t m_ROSpecID;
18800 
18803  public:
18804  static const CFieldDescriptor
18805  s_fdROSpecID;
18807 
18809  inline llrp_u32_t
18811  {
18812  return m_ROSpecID;
18813  }
18814 
18816  inline void
18818  llrp_u32_t value)
18819  {
18820  m_ROSpecID = value;
18821  }
18822 
18823 
18824  protected:
18825  llrp_u16_t m_SpecIndex;
18826 
18829  public:
18830  static const CFieldDescriptor
18831  s_fdSpecIndex;
18833 
18835  inline llrp_u16_t
18837  {
18838  return m_SpecIndex;
18839  }
18840 
18842  inline void
18844  llrp_u16_t value)
18845  {
18846  m_SpecIndex = value;
18847  }
18848 
18849 
18850 
18851  protected:
18852  CParameter * m_pAirProtocolSingulationDetails;
18853 
18854  public:
18856  inline CParameter *
18858  {
18859  return m_pAirProtocolSingulationDetails;
18860  }
18861 
18863  EResultCode
18864  setAirProtocolSingulationDetails (
18865  CParameter * pValue);
18866 
18867 
18868 };
18869 
18870 
18902 class CAntennaEvent : public CParameter
18903 {
18904  public:
18905  CAntennaEvent (void);
18906  ~CAntennaEvent (void);
18907 
18910 
18911  static const CFieldDescriptor * const
18912  s_apFieldDescriptorTable[];
18913 
18914  static const CTypeDescriptor
18915  s_typeDescriptor;
18916 
18917  void
18918  decodeFields (
18919  CDecoderStream * pDecoderStream);
18920 
18921  void
18922  assimilateSubParameters (
18923  CErrorDetails * pError);
18924 
18925  void
18926  encode (
18927  CEncoderStream * pEncoderStream) const;
18928 
18929 
18930 
18931  static CElement *
18932  s_construct (void);
18933 
18934  static void
18935  s_decodeFields (
18936  CDecoderStream * pDecoderStream,
18937  CElement * pElement);
18939 
18940 
18941  protected:
18942  EAntennaEventType m_eEventType;
18943 
18946  public:
18947  static const CFieldDescriptor
18948  s_fdEventType;
18950 
18952  inline EAntennaEventType
18954  {
18955  return m_eEventType;
18956  }
18957 
18959  inline void
18961  EAntennaEventType value)
18962  {
18963  m_eEventType = value;
18964  }
18965 
18966 
18967  protected:
18968  llrp_u16_t m_AntennaID;
18969 
18972  public:
18973  static const CFieldDescriptor
18974  s_fdAntennaID;
18976 
18978  inline llrp_u16_t
18980  {
18981  return m_AntennaID;
18982  }
18983 
18985  inline void
18987  llrp_u16_t value)
18988  {
18989  m_AntennaID = value;
18990  }
18991 
18992 
18993 
18994 };
18995 
18996 
19027 class CConnectionAttemptEvent : public CParameter
19028 {
19029  public:
19030  CConnectionAttemptEvent (void);
19031  ~CConnectionAttemptEvent (void);
19032 
19035 
19036  static const CFieldDescriptor * const
19037  s_apFieldDescriptorTable[];
19038 
19039  static const CTypeDescriptor
19040  s_typeDescriptor;
19041 
19042  void
19043  decodeFields (
19044  CDecoderStream * pDecoderStream);
19045 
19046  void
19047  assimilateSubParameters (
19048  CErrorDetails * pError);
19049 
19050  void
19051  encode (
19052  CEncoderStream * pEncoderStream) const;
19053 
19054 
19055 
19056  static CElement *
19057  s_construct (void);
19058 
19059  static void
19060  s_decodeFields (
19061  CDecoderStream * pDecoderStream,
19062  CElement * pElement);
19064 
19065 
19066  protected:
19067  EConnectionAttemptStatusType m_eStatus;
19068 
19071  public:
19072  static const CFieldDescriptor
19073  s_fdStatus;
19075 
19077  inline EConnectionAttemptStatusType
19078  getStatus (void)
19079  {
19080  return m_eStatus;
19081  }
19082 
19084  inline void
19086  EConnectionAttemptStatusType value)
19087  {
19088  m_eStatus = value;
19089  }
19090 
19091 
19092 
19093 };
19094 
19095 
19136 class CConnectionCloseEvent : public CParameter
19137 {
19138  public:
19139  CConnectionCloseEvent (void);
19140  ~CConnectionCloseEvent (void);
19141 
19144 
19145  static const CFieldDescriptor * const
19146  s_apFieldDescriptorTable[];
19147 
19148  static const CTypeDescriptor
19149  s_typeDescriptor;
19150 
19151  void
19152  decodeFields (
19153  CDecoderStream * pDecoderStream);
19154 
19155  void
19156  assimilateSubParameters (
19157  CErrorDetails * pError);
19158 
19159  void
19160  encode (
19161  CEncoderStream * pEncoderStream) const;
19162 
19163 
19164 
19165  static CElement *
19166  s_construct (void);
19167 
19168  static void
19169  s_decodeFields (
19170  CDecoderStream * pDecoderStream,
19171  CElement * pElement);
19173 
19174 
19175 
19176 };
19177 
19178 
19205 class CLLRPStatus : public CParameter
19206 {
19207  public:
19208  CLLRPStatus (void);
19209  ~CLLRPStatus (void);
19210 
19213 
19214  static const CFieldDescriptor * const
19215  s_apFieldDescriptorTable[];
19216 
19217  static const CTypeDescriptor
19218  s_typeDescriptor;
19219 
19220  void
19221  decodeFields (
19222  CDecoderStream * pDecoderStream);
19223 
19224  void
19225  assimilateSubParameters (
19226  CErrorDetails * pError);
19227 
19228  void
19229  encode (
19230  CEncoderStream * pEncoderStream) const;
19231 
19232 
19233 
19234  static CElement *
19235  s_construct (void);
19236 
19237  static void
19238  s_decodeFields (
19239  CDecoderStream * pDecoderStream,
19240  CElement * pElement);
19242 
19243 
19244  protected:
19245  EStatusCode m_eStatusCode;
19246 
19249  public:
19250  static const CFieldDescriptor
19251  s_fdStatusCode;
19253 
19255  inline EStatusCode
19257  {
19258  return m_eStatusCode;
19259  }
19260 
19262  inline void
19264  EStatusCode value)
19265  {
19266  m_eStatusCode = value;
19267  }
19268 
19269 
19270  protected:
19271  llrp_utf8v_t m_ErrorDescription;
19272 
19275  public:
19276  static const CFieldDescriptor
19277  s_fdErrorDescription;
19279 
19281  inline llrp_utf8v_t
19283  {
19284  return m_ErrorDescription;
19285  }
19286 
19288  inline void
19290  llrp_utf8v_t value)
19291  {
19292  m_ErrorDescription = value;
19293  }
19294 
19295 
19296 
19297  protected:
19298  CFieldError * m_pFieldError;
19299 
19300  public:
19302  inline CFieldError *
19304  {
19305  return m_pFieldError;
19306  }
19307 
19309  EResultCode
19310  setFieldError (
19311  CFieldError * pValue);
19312 
19313 
19314  protected:
19315  CParameterError * m_pParameterError;
19316 
19317  public:
19319  inline CParameterError *
19321  {
19322  return m_pParameterError;
19323  }
19324 
19326  EResultCode
19327  setParameterError (
19328  CParameterError * pValue);
19329 
19330 
19331 };
19332 
19333 
19365 class CFieldError : public CParameter
19366 {
19367  public:
19368  CFieldError (void);
19369  ~CFieldError (void);
19370 
19373 
19374  static const CFieldDescriptor * const
19375  s_apFieldDescriptorTable[];
19376 
19377  static const CTypeDescriptor
19378  s_typeDescriptor;
19379 
19380  void
19381  decodeFields (
19382  CDecoderStream * pDecoderStream);
19383 
19384  void
19385  assimilateSubParameters (
19386  CErrorDetails * pError);
19387 
19388  void
19389  encode (
19390  CEncoderStream * pEncoderStream) const;
19391 
19392 
19393 
19394  static CElement *
19395  s_construct (void);
19396 
19397  static void
19398  s_decodeFields (
19399  CDecoderStream * pDecoderStream,
19400  CElement * pElement);
19402 
19403 
19404  protected:
19405  llrp_u16_t m_FieldNum;
19406 
19409  public:
19410  static const CFieldDescriptor
19411  s_fdFieldNum;
19413 
19415  inline llrp_u16_t
19417  {
19418  return m_FieldNum;
19419  }
19420 
19422  inline void
19424  llrp_u16_t value)
19425  {
19426  m_FieldNum = value;
19427  }
19428 
19429 
19430  protected:
19431  EStatusCode m_eErrorCode;
19432 
19435  public:
19436  static const CFieldDescriptor
19437  s_fdErrorCode;
19439 
19441  inline EStatusCode
19443  {
19444  return m_eErrorCode;
19445  }
19446 
19448  inline void
19450  EStatusCode value)
19451  {
19452  m_eErrorCode = value;
19453  }
19454 
19455 
19456 
19457 };
19458 
19459 
19493 class CParameterError : public CParameter
19494 {
19495  public:
19496  CParameterError (void);
19497  ~CParameterError (void);
19498 
19501 
19502  static const CFieldDescriptor * const
19503  s_apFieldDescriptorTable[];
19504 
19505  static const CTypeDescriptor
19506  s_typeDescriptor;
19507 
19508  void
19509  decodeFields (
19510  CDecoderStream * pDecoderStream);
19511 
19512  void
19513  assimilateSubParameters (
19514  CErrorDetails * pError);
19515 
19516  void
19517  encode (
19518  CEncoderStream * pEncoderStream) const;
19519 
19520 
19521 
19522  static CElement *
19523  s_construct (void);
19524 
19525  static void
19526  s_decodeFields (
19527  CDecoderStream * pDecoderStream,
19528  CElement * pElement);
19530 
19531 
19532  protected:
19533  llrp_u16_t m_ParameterType;
19534 
19537  public:
19538  static const CFieldDescriptor
19539  s_fdParameterType;
19541 
19543  inline llrp_u16_t
19545  {
19546  return m_ParameterType;
19547  }
19548 
19550  inline void
19552  llrp_u16_t value)
19553  {
19554  m_ParameterType = value;
19555  }
19556 
19557 
19558  protected:
19559  EStatusCode m_eErrorCode;
19560 
19563  public:
19564  static const CFieldDescriptor
19565  s_fdErrorCode;
19567 
19569  inline EStatusCode
19571  {
19572  return m_eErrorCode;
19573  }
19574 
19576  inline void
19578  EStatusCode value)
19579  {
19580  m_eErrorCode = value;
19581  }
19582 
19583 
19584 
19585  protected:
19586  CFieldError * m_pFieldError;
19587 
19588  public:
19590  inline CFieldError *
19592  {
19593  return m_pFieldError;
19594  }
19595 
19597  EResultCode
19598  setFieldError (
19599  CFieldError * pValue);
19600 
19601 
19602  protected:
19603  CParameterError * m_pParameterError;
19604 
19605  public:
19607  inline CParameterError *
19609  {
19610  return m_pParameterError;
19611  }
19612 
19614  EResultCode
19615  setParameterError (
19616  CParameterError * pValue);
19617 
19618 
19619 };
19620 
19621 
19661 class CC1G2LLRPCapabilities : public CParameter
19662 {
19663  public:
19664  CC1G2LLRPCapabilities (void);
19665  ~CC1G2LLRPCapabilities (void);
19666 
19669 
19670  static const CFieldDescriptor * const
19671  s_apFieldDescriptorTable[];
19672 
19673  static const CTypeDescriptor
19674  s_typeDescriptor;
19675 
19676  void
19677  decodeFields (
19678  CDecoderStream * pDecoderStream);
19679 
19680  void
19681  assimilateSubParameters (
19682  CErrorDetails * pError);
19683 
19684  void
19685  encode (
19686  CEncoderStream * pEncoderStream) const;
19687 
19688 
19689 
19690  static CElement *
19691  s_construct (void);
19692 
19693  static void
19694  s_decodeFields (
19695  CDecoderStream * pDecoderStream,
19696  CElement * pElement);
19698 
19699 
19700  protected:
19701  llrp_u1_t m_CanSupportBlockErase;
19702 
19705  public:
19706  static const CFieldDescriptor
19707  s_fdCanSupportBlockErase;
19709 
19711  inline llrp_u1_t
19713  {
19714  return m_CanSupportBlockErase;
19715  }
19716 
19718  inline void
19720  llrp_u1_t value)
19721  {
19722  m_CanSupportBlockErase = value;
19723  }
19724 
19725 
19726  protected:
19727  llrp_u1_t m_CanSupportBlockWrite;
19728 
19731  public:
19732  static const CFieldDescriptor
19733  s_fdCanSupportBlockWrite;
19735 
19737  inline llrp_u1_t
19739  {
19740  return m_CanSupportBlockWrite;
19741  }
19742 
19744  inline void
19746  llrp_u1_t value)
19747  {
19748  m_CanSupportBlockWrite = value;
19749  }
19750 
19751 
19752  protected:
19753  llrp_u16_t m_MaxNumSelectFiltersPerQuery;
19754 
19757  public:
19758  static const CFieldDescriptor
19759  s_fdMaxNumSelectFiltersPerQuery;
19761 
19763  inline llrp_u16_t
19765  {
19766  return m_MaxNumSelectFiltersPerQuery;
19767  }
19768 
19770  inline void
19772  llrp_u16_t value)
19773  {
19774  m_MaxNumSelectFiltersPerQuery = value;
19775  }
19776 
19777 
19778 
19779 };
19780 
19781 
19812 class CC1G2UHFRFModeTable : public CParameter
19813 {
19814  public:
19815  CC1G2UHFRFModeTable (void);
19816  ~CC1G2UHFRFModeTable (void);
19817 
19820 
19821  static const CFieldDescriptor * const
19822  s_apFieldDescriptorTable[];
19823 
19824  static const CTypeDescriptor
19825  s_typeDescriptor;
19826 
19827  void
19828  decodeFields (
19829  CDecoderStream * pDecoderStream);
19830 
19831  void
19832  assimilateSubParameters (
19833  CErrorDetails * pError);
19834 
19835  void
19836  encode (
19837  CEncoderStream * pEncoderStream) const;
19838 
19839 
19840 
19841  static CElement *
19842  s_construct (void);
19843 
19844  static void
19845  s_decodeFields (
19846  CDecoderStream * pDecoderStream,
19847  CElement * pElement);
19849 
19850 
19851 
19852  protected:
19853  std::list<CC1G2UHFRFModeTableEntry *> m_listC1G2UHFRFModeTableEntry;
19854 
19855  public:
19857  inline std::list<CC1G2UHFRFModeTableEntry *>::iterator
19859  {
19860  return m_listC1G2UHFRFModeTableEntry.begin();
19861  }
19862 
19864  inline std::list<CC1G2UHFRFModeTableEntry *>::iterator
19866  {
19867  return m_listC1G2UHFRFModeTableEntry.end();
19868  }
19869 
19871  inline void
19873  {
19874  clearSubParameterList ((tListOfParameters *) &m_listC1G2UHFRFModeTableEntry);
19875  }
19876 
19878  inline int
19880  {
19881  return (int) (m_listC1G2UHFRFModeTableEntry.size());
19882  }
19883 
19884  EResultCode
19886  addC1G2UHFRFModeTableEntry (
19887  CC1G2UHFRFModeTableEntry * pValue);
19888 
19889 
19890 };
19891 
19892 
19934 class CC1G2UHFRFModeTableEntry : public CParameter
19935 {
19936  public:
19937  CC1G2UHFRFModeTableEntry (void);
19938  ~CC1G2UHFRFModeTableEntry (void);
19939 
19942 
19943  static const CFieldDescriptor * const
19944  s_apFieldDescriptorTable[];
19945 
19946  static const CTypeDescriptor
19947  s_typeDescriptor;
19948 
19949  void
19950  decodeFields (
19951  CDecoderStream * pDecoderStream);
19952 
19953  void
19954  assimilateSubParameters (
19955  CErrorDetails * pError);
19956 
19957  void
19958  encode (
19959  CEncoderStream * pEncoderStream) const;
19960 
19961 
19962 
19963  static CElement *
19964  s_construct (void);
19965 
19966  static void
19967  s_decodeFields (
19968  CDecoderStream * pDecoderStream,
19969  CElement * pElement);
19971 
19972 
19973  protected:
19974  llrp_u32_t m_ModeIdentifier;
19975 
19978  public:
19979  static const CFieldDescriptor
19980  s_fdModeIdentifier;
19982 
19984  inline llrp_u32_t
19986  {
19987  return m_ModeIdentifier;
19988  }
19989 
19991  inline void
19993  llrp_u32_t value)
19994  {
19995  m_ModeIdentifier = value;
19996  }
19997 
19998 
19999  protected:
20000  EC1G2DRValue m_eDRValue;
20001 
20004  public:
20005  static const CFieldDescriptor
20006  s_fdDRValue;
20008 
20010  inline EC1G2DRValue
20011  getDRValue (void)
20012  {
20013  return m_eDRValue;
20014  }
20015 
20017  inline void
20019  EC1G2DRValue value)
20020  {
20021  m_eDRValue = value;
20022  }
20023 
20024 
20025  protected:
20026  llrp_u1_t m_EPCHAGTCConformance;
20027 
20030  public:
20031  static const CFieldDescriptor
20032  s_fdEPCHAGTCConformance;
20034 
20036  inline llrp_u1_t
20038  {
20039  return m_EPCHAGTCConformance;
20040  }
20041 
20043  inline void
20045  llrp_u1_t value)
20046  {
20047  m_EPCHAGTCConformance = value;
20048  }
20049 
20050 
20051  protected:
20052  EC1G2MValue m_eMValue;
20053 
20056  public:
20057  static const CFieldDescriptor
20058  s_fdMValue;
20060 
20062  inline EC1G2MValue
20063  getMValue (void)
20064  {
20065  return m_eMValue;
20066  }
20067 
20069  inline void
20071  EC1G2MValue value)
20072  {
20073  m_eMValue = value;
20074  }
20075 
20076 
20077  protected:
20078  EC1G2ForwardLinkModulation m_eForwardLinkModulation;
20079 
20082  public:
20083  static const CFieldDescriptor
20084  s_fdForwardLinkModulation;
20086 
20088  inline EC1G2ForwardLinkModulation
20090  {
20091  return m_eForwardLinkModulation;
20092  }
20093 
20095  inline void
20097  EC1G2ForwardLinkModulation value)
20098  {
20099  m_eForwardLinkModulation = value;
20100  }
20101 
20102 
20103  protected:
20104  EC1G2SpectralMaskIndicator m_eSpectralMaskIndicator;
20105 
20108  public:
20109  static const CFieldDescriptor
20110  s_fdSpectralMaskIndicator;
20112 
20114  inline EC1G2SpectralMaskIndicator
20116  {
20117  return m_eSpectralMaskIndicator;
20118  }
20119 
20121  inline void
20123  EC1G2SpectralMaskIndicator value)
20124  {
20125  m_eSpectralMaskIndicator = value;
20126  }
20127 
20128 
20129  protected:
20130  llrp_u32_t m_BDRValue;
20131 
20134  public:
20135  static const CFieldDescriptor
20136  s_fdBDRValue;
20138 
20140  inline llrp_u32_t
20142  {
20143  return m_BDRValue;
20144  }
20145 
20147  inline void
20149  llrp_u32_t value)
20150  {
20151  m_BDRValue = value;
20152  }
20153 
20154 
20155  protected:
20156  llrp_u32_t m_PIEValue;
20157 
20160  public:
20161  static const CFieldDescriptor
20162  s_fdPIEValue;
20164 
20166  inline llrp_u32_t
20168  {
20169  return m_PIEValue;
20170  }
20171 
20173  inline void
20175  llrp_u32_t value)
20176  {
20177  m_PIEValue = value;
20178  }
20179 
20180 
20181  protected:
20182  llrp_u32_t m_MinTariValue;
20183 
20186  public:
20187  static const CFieldDescriptor
20188  s_fdMinTariValue;
20190 
20192  inline llrp_u32_t
20194  {
20195  return m_MinTariValue;
20196  }
20197 
20199  inline void
20201  llrp_u32_t value)
20202  {
20203  m_MinTariValue = value;
20204  }
20205 
20206 
20207  protected:
20208  llrp_u32_t m_MaxTariValue;
20209 
20212  public:
20213  static const CFieldDescriptor
20214  s_fdMaxTariValue;
20216 
20218  inline llrp_u32_t
20220  {
20221  return m_MaxTariValue;
20222  }
20223 
20225  inline void
20227  llrp_u32_t value)
20228  {
20229  m_MaxTariValue = value;
20230  }
20231 
20232 
20233  protected:
20234  llrp_u32_t m_StepTariValue;
20235 
20238  public:
20239  static const CFieldDescriptor
20240  s_fdStepTariValue;
20242 
20244  inline llrp_u32_t
20246  {
20247  return m_StepTariValue;
20248  }
20249 
20251  inline void
20253  llrp_u32_t value)
20254  {
20255  m_StepTariValue = value;
20256  }
20257 
20258 
20259 
20260 };
20261 
20262 
20303 class CC1G2InventoryCommand : public CParameter
20304 {
20305  public:
20306  CC1G2InventoryCommand (void);
20307  ~CC1G2InventoryCommand (void);
20308 
20311 
20312  static const CFieldDescriptor * const
20313  s_apFieldDescriptorTable[];
20314 
20315  static const CTypeDescriptor
20316  s_typeDescriptor;
20317 
20318  void
20319  decodeFields (
20320  CDecoderStream * pDecoderStream);
20321 
20322  void
20323  assimilateSubParameters (
20324  CErrorDetails * pError);
20325 
20326  void
20327  encode (
20328  CEncoderStream * pEncoderStream) const;
20329 
20330 
20331 
20332  static CElement *
20333  s_construct (void);
20334 
20335  static void
20336  s_decodeFields (
20337  CDecoderStream * pDecoderStream,
20338  CElement * pElement);
20340 
20341 
20342  protected:
20343  llrp_u1_t m_TagInventoryStateAware;
20344 
20347  public:
20348  static const CFieldDescriptor
20349  s_fdTagInventoryStateAware;
20351 
20353  inline llrp_u1_t
20355  {
20356  return m_TagInventoryStateAware;
20357  }
20358 
20360  inline void
20362  llrp_u1_t value)
20363  {
20364  m_TagInventoryStateAware = value;
20365  }
20366 
20367 
20368 
20369  protected:
20370  std::list<CC1G2Filter *> m_listC1G2Filter;
20371 
20372  public:
20374  inline std::list<CC1G2Filter *>::iterator
20376  {
20377  return m_listC1G2Filter.begin();
20378  }
20379 
20381  inline std::list<CC1G2Filter *>::iterator
20383  {
20384  return m_listC1G2Filter.end();
20385  }
20386 
20388  inline void
20390  {
20391  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
20392  }
20393 
20395  inline int
20397  {
20398  return (int) (m_listC1G2Filter.size());
20399  }
20400 
20401  EResultCode
20403  addC1G2Filter (
20404  CC1G2Filter * pValue);
20405 
20406 
20407  protected:
20408  CC1G2RFControl * m_pC1G2RFControl;
20409 
20410  public:
20412  inline CC1G2RFControl *
20414  {
20415  return m_pC1G2RFControl;
20416  }
20417 
20419  EResultCode
20420  setC1G2RFControl (
20421  CC1G2RFControl * pValue);
20422 
20423 
20424  protected:
20425  CC1G2SingulationControl * m_pC1G2SingulationControl;
20426 
20427  public:
20429  inline CC1G2SingulationControl *
20431  {
20432  return m_pC1G2SingulationControl;
20433  }
20434 
20436  EResultCode
20437  setC1G2SingulationControl (
20438  CC1G2SingulationControl * pValue);
20439 
20440 
20441  protected:
20442  std::list<CParameter *> m_listCustom;
20443 
20444  public:
20446  inline std::list<CParameter *>::iterator
20448  {
20449  return m_listCustom.begin();
20450  }
20451 
20453  inline std::list<CParameter *>::iterator
20454  endCustom (void)
20455  {
20456  return m_listCustom.end();
20457  }
20458 
20460  inline void
20462  {
20463  clearSubParameterList ((tListOfParameters *) &m_listCustom);
20464  }
20465 
20467  inline int
20469  {
20470  return (int) (m_listCustom.size());
20471  }
20472 
20473  EResultCode
20475  addCustom (
20476  CParameter * pValue);
20477 
20478 
20479 };
20480 
20481 
20540 class CC1G2Filter : public CParameter
20541 {
20542  public:
20543  CC1G2Filter (void);
20544  ~CC1G2Filter (void);
20545 
20548 
20549  static const CFieldDescriptor * const
20550  s_apFieldDescriptorTable[];
20551 
20552  static const CTypeDescriptor
20553  s_typeDescriptor;
20554 
20555  void
20556  decodeFields (
20557  CDecoderStream * pDecoderStream);
20558 
20559  void
20560  assimilateSubParameters (
20561  CErrorDetails * pError);
20562 
20563  void
20564  encode (
20565  CEncoderStream * pEncoderStream) const;
20566 
20567 
20568 
20569  static CElement *
20570  s_construct (void);
20571 
20572  static void
20573  s_decodeFields (
20574  CDecoderStream * pDecoderStream,
20575  CElement * pElement);
20577 
20578 
20579  protected:
20580  EC1G2TruncateAction m_eT;
20581 
20584  public:
20585  static const CFieldDescriptor
20586  s_fdT;
20588 
20590  inline EC1G2TruncateAction
20591  getT (void)
20592  {
20593  return m_eT;
20594  }
20595 
20597  inline void
20599  EC1G2TruncateAction value)
20600  {
20601  m_eT = value;
20602  }
20603 
20604 
20605 
20606  protected:
20607  CC1G2TagInventoryMask * m_pC1G2TagInventoryMask;
20608 
20609  public:
20611  inline CC1G2TagInventoryMask *
20613  {
20614  return m_pC1G2TagInventoryMask;
20615  }
20616 
20618  EResultCode
20619  setC1G2TagInventoryMask (
20620  CC1G2TagInventoryMask * pValue);
20621 
20622 
20623  protected:
20624  CC1G2TagInventoryStateAwareFilterAction * m_pC1G2TagInventoryStateAwareFilterAction;
20625 
20626  public:
20630  {
20631  return m_pC1G2TagInventoryStateAwareFilterAction;
20632  }
20633 
20635  EResultCode
20636  setC1G2TagInventoryStateAwareFilterAction (
20638 
20639 
20640  protected:
20641  CC1G2TagInventoryStateUnawareFilterAction * m_pC1G2TagInventoryStateUnawareFilterAction;
20642 
20643  public:
20647  {
20648  return m_pC1G2TagInventoryStateUnawareFilterAction;
20649  }
20650 
20652  EResultCode
20653  setC1G2TagInventoryStateUnawareFilterAction (
20655 
20656 
20657 };
20658 
20659 
20686 class CC1G2TagInventoryMask : public CParameter
20687 {
20688  public:
20689  CC1G2TagInventoryMask (void);
20690  ~CC1G2TagInventoryMask (void);
20691 
20694 
20695  static const CFieldDescriptor * const
20696  s_apFieldDescriptorTable[];
20697 
20698  static const CTypeDescriptor
20699  s_typeDescriptor;
20700 
20701  void
20702  decodeFields (
20703  CDecoderStream * pDecoderStream);
20704 
20705  void
20706  assimilateSubParameters (
20707  CErrorDetails * pError);
20708 
20709  void
20710  encode (
20711  CEncoderStream * pEncoderStream) const;
20712 
20713 
20714 
20715  static CElement *
20716  s_construct (void);
20717 
20718  static void
20719  s_decodeFields (
20720  CDecoderStream * pDecoderStream,
20721  CElement * pElement);
20723 
20724 
20725  protected:
20726  llrp_u2_t m_MB;
20727 
20730  public:
20731  static const CFieldDescriptor
20732  s_fdMB;
20734 
20736  inline llrp_u2_t
20737  getMB (void)
20738  {
20739  return m_MB;
20740  }
20741 
20743  inline void
20745  llrp_u2_t value)
20746  {
20747  m_MB = value;
20748  }
20749 
20750 
20751  protected:
20752  llrp_u16_t m_Pointer;
20753 
20756  public:
20757  static const CFieldDescriptor
20758  s_fdPointer;
20760 
20762  inline llrp_u16_t
20763  getPointer (void)
20764  {
20765  return m_Pointer;
20766  }
20767 
20769  inline void
20771  llrp_u16_t value)
20772  {
20773  m_Pointer = value;
20774  }
20775 
20776 
20777  protected:
20778  llrp_u1v_t m_TagMask;
20779 
20782  public:
20783  static const CFieldDescriptor
20784  s_fdTagMask;
20786 
20788  inline llrp_u1v_t
20789  getTagMask (void)
20790  {
20791  return m_TagMask;
20792  }
20793 
20795  inline void
20797  llrp_u1v_t value)
20798  {
20799  m_TagMask = value;
20800  }
20801 
20802 
20803 
20804 };
20805 
20806 
20857 class CC1G2TagInventoryStateAwareFilterAction : public CParameter
20858 {
20859  public:
20862 
20865 
20866  static const CFieldDescriptor * const
20867  s_apFieldDescriptorTable[];
20868 
20869  static const CTypeDescriptor
20870  s_typeDescriptor;
20871 
20872  void
20873  decodeFields (
20874  CDecoderStream * pDecoderStream);
20875 
20876  void
20877  assimilateSubParameters (
20878  CErrorDetails * pError);
20879 
20880  void
20881  encode (
20882  CEncoderStream * pEncoderStream) const;
20883 
20884 
20885 
20886  static CElement *
20887  s_construct (void);
20888 
20889  static void
20890  s_decodeFields (
20891  CDecoderStream * pDecoderStream,
20892  CElement * pElement);
20894 
20895 
20896  protected:
20897  EC1G2StateAwareTarget m_eTarget;
20898 
20901  public:
20902  static const CFieldDescriptor
20903  s_fdTarget;
20905 
20907  inline EC1G2StateAwareTarget
20908  getTarget (void)
20909  {
20910  return m_eTarget;
20911  }
20912 
20914  inline void
20916  EC1G2StateAwareTarget value)
20917  {
20918  m_eTarget = value;
20919  }
20920 
20921 
20922  protected:
20923  EC1G2StateAwareAction m_eAction;
20924 
20927  public:
20928  static const CFieldDescriptor
20929  s_fdAction;
20931 
20933  inline EC1G2StateAwareAction
20934  getAction (void)
20935  {
20936  return m_eAction;
20937  }
20938 
20940  inline void
20942  EC1G2StateAwareAction value)
20943  {
20944  m_eAction = value;
20945  }
20946 
20947 
20948 
20949 };
20950 
20951 
20994 class CC1G2TagInventoryStateUnawareFilterAction : public CParameter
20995 {
20996  public:
20999 
21002 
21003  static const CFieldDescriptor * const
21004  s_apFieldDescriptorTable[];
21005 
21006  static const CTypeDescriptor
21007  s_typeDescriptor;
21008 
21009  void
21010  decodeFields (
21011  CDecoderStream * pDecoderStream);
21012 
21013  void
21014  assimilateSubParameters (
21015  CErrorDetails * pError);
21016 
21017  void
21018  encode (
21019  CEncoderStream * pEncoderStream) const;
21020 
21021 
21022 
21023  static CElement *
21024  s_construct (void);
21025 
21026  static void
21027  s_decodeFields (
21028  CDecoderStream * pDecoderStream,
21029  CElement * pElement);
21031 
21032 
21033  protected:
21034  EC1G2StateUnawareAction m_eAction;
21035 
21038  public:
21039  static const CFieldDescriptor
21040  s_fdAction;
21042 
21044  inline EC1G2StateUnawareAction
21045  getAction (void)
21046  {
21047  return m_eAction;
21048  }
21049 
21051  inline void
21053  EC1G2StateUnawareAction value)
21054  {
21055  m_eAction = value;
21056  }
21057 
21058 
21059 
21060 };
21061 
21062 
21097 class CC1G2RFControl : public CParameter
21098 {
21099  public:
21100  CC1G2RFControl (void);
21101  ~CC1G2RFControl (void);
21102 
21105 
21106  static const CFieldDescriptor * const
21107  s_apFieldDescriptorTable[];
21108 
21109  static const CTypeDescriptor
21110  s_typeDescriptor;
21111 
21112  void
21113  decodeFields (
21114  CDecoderStream * pDecoderStream);
21115 
21116  void
21117  assimilateSubParameters (
21118  CErrorDetails * pError);
21119 
21120  void
21121  encode (
21122  CEncoderStream * pEncoderStream) const;
21123 
21124 
21125 
21126  static CElement *
21127  s_construct (void);
21128 
21129  static void
21130  s_decodeFields (
21131  CDecoderStream * pDecoderStream,
21132  CElement * pElement);
21134 
21135 
21136  protected:
21137  llrp_u16_t m_ModeIndex;
21138 
21141  public:
21142  static const CFieldDescriptor
21143  s_fdModeIndex;
21145 
21147  inline llrp_u16_t
21149  {
21150  return m_ModeIndex;
21151  }
21152 
21154  inline void
21156  llrp_u16_t value)
21157  {
21158  m_ModeIndex = value;
21159  }
21160 
21161 
21162  protected:
21163  llrp_u16_t m_Tari;
21164 
21167  public:
21168  static const CFieldDescriptor
21169  s_fdTari;
21171 
21173  inline llrp_u16_t
21174  getTari (void)
21175  {
21176  return m_Tari;
21177  }
21178 
21180  inline void
21182  llrp_u16_t value)
21183  {
21184  m_Tari = value;
21185  }
21186 
21187 
21188 
21189 };
21190 
21191 
21276 class CC1G2SingulationControl : public CParameter
21277 {
21278  public:
21279  CC1G2SingulationControl (void);
21280  ~CC1G2SingulationControl (void);
21281 
21284 
21285  static const CFieldDescriptor * const
21286  s_apFieldDescriptorTable[];
21287 
21288  static const CTypeDescriptor
21289  s_typeDescriptor;
21290 
21291  void
21292  decodeFields (
21293  CDecoderStream * pDecoderStream);
21294 
21295  void
21296  assimilateSubParameters (
21297  CErrorDetails * pError);
21298 
21299  void
21300  encode (
21301  CEncoderStream * pEncoderStream) const;
21302 
21303 
21304 
21305  static CElement *
21306  s_construct (void);
21307 
21308  static void
21309  s_decodeFields (
21310  CDecoderStream * pDecoderStream,
21311  CElement * pElement);
21313 
21314 
21315  protected:
21316  llrp_u2_t m_Session;
21317 
21320  public:
21321  static const CFieldDescriptor
21322  s_fdSession;
21324 
21326  inline llrp_u2_t
21327  getSession (void)
21328  {
21329  return m_Session;
21330  }
21331 
21333  inline void
21335  llrp_u2_t value)
21336  {
21337  m_Session = value;
21338  }
21339 
21340 
21341  protected:
21342  llrp_u16_t m_TagPopulation;
21343 
21346  public:
21347  static const CFieldDescriptor
21348  s_fdTagPopulation;
21350 
21352  inline llrp_u16_t
21354  {
21355  return m_TagPopulation;
21356  }
21357 
21359  inline void
21361  llrp_u16_t value)
21362  {
21363  m_TagPopulation = value;
21364  }
21365 
21366 
21367  protected:
21368  llrp_u32_t m_TagTransitTime;
21369 
21372  public:
21373  static const CFieldDescriptor
21374  s_fdTagTransitTime;
21376 
21378  inline llrp_u32_t
21380  {
21381  return m_TagTransitTime;
21382  }
21383 
21385  inline void
21387  llrp_u32_t value)
21388  {
21389  m_TagTransitTime = value;
21390  }
21391 
21392 
21393 
21394  protected:
21395  CC1G2TagInventoryStateAwareSingulationAction * m_pC1G2TagInventoryStateAwareSingulationAction;
21396 
21397  public:
21401  {
21402  return m_pC1G2TagInventoryStateAwareSingulationAction;
21403  }
21404 
21406  EResultCode
21407  setC1G2TagInventoryStateAwareSingulationAction (
21409 
21410 
21411 };
21412 
21413 
21446 class CC1G2TagInventoryStateAwareSingulationAction : public CParameter
21447 {
21448  public:
21451 
21454 
21455  static const CFieldDescriptor * const
21456  s_apFieldDescriptorTable[];
21457 
21458  static const CTypeDescriptor
21459  s_typeDescriptor;
21460 
21461  void
21462  decodeFields (
21463  CDecoderStream * pDecoderStream);
21464 
21465  void
21466  assimilateSubParameters (
21467  CErrorDetails * pError);
21468 
21469  void
21470  encode (
21471  CEncoderStream * pEncoderStream) const;
21472 
21473 
21474 
21475  static CElement *
21476  s_construct (void);
21477 
21478  static void
21479  s_decodeFields (
21480  CDecoderStream * pDecoderStream,
21481  CElement * pElement);
21483 
21484 
21485  protected:
21486  EC1G2TagInventoryStateAwareI m_eI;
21487 
21490  public:
21491  static const CFieldDescriptor
21492  s_fdI;
21494 
21496  inline EC1G2TagInventoryStateAwareI
21497  getI (void)
21498  {
21499  return m_eI;
21500  }
21501 
21503  inline void
21505  EC1G2TagInventoryStateAwareI value)
21506  {
21507  m_eI = value;
21508  }
21509 
21510 
21511  protected:
21512  EC1G2TagInventoryStateAwareS m_eS;
21513 
21516  public:
21517  static const CFieldDescriptor
21518  s_fdS;
21520 
21522  inline EC1G2TagInventoryStateAwareS
21523  getS (void)
21524  {
21525  return m_eS;
21526  }
21527 
21529  inline void
21531  EC1G2TagInventoryStateAwareS value)
21532  {
21533  m_eS = value;
21534  }
21535 
21536 
21537 
21538 };
21539 
21540 
21577 class CC1G2TagSpec : public CParameter
21578 {
21579  public:
21580  CC1G2TagSpec (void);
21581  ~CC1G2TagSpec (void);
21582 
21585 
21586  static const CFieldDescriptor * const
21587  s_apFieldDescriptorTable[];
21588 
21589  static const CTypeDescriptor
21590  s_typeDescriptor;
21591 
21592  void
21593  decodeFields (
21594  CDecoderStream * pDecoderStream);
21595 
21596  void
21597  assimilateSubParameters (
21598  CErrorDetails * pError);
21599 
21600  void
21601  encode (
21602  CEncoderStream * pEncoderStream) const;
21603 
21604 
21605 
21606  static CElement *
21607  s_construct (void);
21608 
21609  static void
21610  s_decodeFields (
21611  CDecoderStream * pDecoderStream,
21612  CElement * pElement);
21614 
21615 
21616 
21617  protected:
21618  std::list<CC1G2TargetTag *> m_listC1G2TargetTag;
21619 
21620  public:
21622  inline std::list<CC1G2TargetTag *>::iterator
21624  {
21625  return m_listC1G2TargetTag.begin();
21626  }
21627 
21629  inline std::list<CC1G2TargetTag *>::iterator
21631  {
21632  return m_listC1G2TargetTag.end();
21633  }
21634 
21636  inline void
21638  {
21639  clearSubParameterList ((tListOfParameters *) &m_listC1G2TargetTag);
21640  }
21641 
21643  inline int
21645  {
21646  return (int) (m_listC1G2TargetTag.size());
21647  }
21648 
21649  EResultCode
21651  addC1G2TargetTag (
21652  CC1G2TargetTag * pValue);
21653 
21654 
21655 };
21656 
21657 
21693 class CC1G2TargetTag : public CParameter
21694 {
21695  public:
21696  CC1G2TargetTag (void);
21697  ~CC1G2TargetTag (void);
21698 
21701 
21702  static const CFieldDescriptor * const
21703  s_apFieldDescriptorTable[];
21704 
21705  static const CTypeDescriptor
21706  s_typeDescriptor;
21707 
21708  void
21709  decodeFields (
21710  CDecoderStream * pDecoderStream);
21711 
21712  void
21713  assimilateSubParameters (
21714  CErrorDetails * pError);
21715 
21716  void
21717  encode (
21718  CEncoderStream * pEncoderStream) const;
21719 
21720 
21721 
21722  static CElement *
21723  s_construct (void);
21724 
21725  static void
21726  s_decodeFields (
21727  CDecoderStream * pDecoderStream,
21728  CElement * pElement);
21730 
21731 
21732  protected:
21733  llrp_u2_t m_MB;
21734 
21737  public:
21738  static const CFieldDescriptor
21739  s_fdMB;
21741 
21743  inline llrp_u2_t
21744  getMB (void)
21745  {
21746  return m_MB;
21747  }
21748 
21750  inline void
21752  llrp_u2_t value)
21753  {
21754  m_MB = value;
21755  }
21756 
21757 
21758  protected:
21759  llrp_u1_t m_Match;
21760 
21763  public:
21764  static const CFieldDescriptor
21765  s_fdMatch;
21767 
21769  inline llrp_u1_t
21770  getMatch (void)
21771  {
21772  return m_Match;
21773  }
21774 
21776  inline void
21778  llrp_u1_t value)
21779  {
21780  m_Match = value;
21781  }
21782 
21783 
21784  protected:
21785  llrp_u16_t m_Pointer;
21786 
21789  public:
21790  static const CFieldDescriptor
21791  s_fdPointer;
21793 
21795  inline llrp_u16_t
21796  getPointer (void)
21797  {
21798  return m_Pointer;
21799  }
21800 
21802  inline void
21804  llrp_u16_t value)
21805  {
21806  m_Pointer = value;
21807  }
21808 
21809 
21810  protected:
21811  llrp_u1v_t m_TagMask;
21812 
21815  public:
21816  static const CFieldDescriptor
21817  s_fdTagMask;
21819 
21821  inline llrp_u1v_t
21822  getTagMask (void)
21823  {
21824  return m_TagMask;
21825  }
21826 
21828  inline void
21830  llrp_u1v_t value)
21831  {
21832  m_TagMask = value;
21833  }
21834 
21835 
21836  protected:
21837  llrp_u1v_t m_TagData;
21838 
21841  public:
21842  static const CFieldDescriptor
21843  s_fdTagData;
21845 
21847  inline llrp_u1v_t
21848  getTagData (void)
21849  {
21850  return m_TagData;
21851  }
21852 
21854  inline void
21856  llrp_u1v_t value)
21857  {
21858  m_TagData = value;
21859  }
21860 
21861 
21862 
21863 };
21864 
21865 
21904 class CC1G2Read : public CParameter
21905 {
21906  public:
21907  CC1G2Read (void);
21908  ~CC1G2Read (void);
21909 
21912 
21913  static const CFieldDescriptor * const
21914  s_apFieldDescriptorTable[];
21915 
21916  static const CTypeDescriptor
21917  s_typeDescriptor;
21918 
21919  void
21920  decodeFields (
21921  CDecoderStream * pDecoderStream);
21922 
21923  void
21924  assimilateSubParameters (
21925  CErrorDetails * pError);
21926 
21927  void
21928  encode (
21929  CEncoderStream * pEncoderStream) const;
21930 
21931 
21932 
21933  static CElement *
21934  s_construct (void);
21935 
21936  static void
21937  s_decodeFields (
21938  CDecoderStream * pDecoderStream,
21939  CElement * pElement);
21941 
21942 
21943  protected:
21944  llrp_u16_t m_OpSpecID;
21945 
21948  public:
21949  static const CFieldDescriptor
21950  s_fdOpSpecID;
21952 
21954  inline llrp_u16_t
21956  {
21957  return m_OpSpecID;
21958  }
21959 
21961  inline void
21963  llrp_u16_t value)
21964  {
21965  m_OpSpecID = value;
21966  }
21967 
21968 
21969  protected:
21970  llrp_u32_t m_AccessPassword;
21971 
21974  public:
21975  static const CFieldDescriptor
21976  s_fdAccessPassword;
21978 
21980  inline llrp_u32_t
21982  {
21983  return m_AccessPassword;
21984  }
21985 
21987  inline void
21989  llrp_u32_t value)
21990  {
21991  m_AccessPassword = value;
21992  }
21993 
21994 
21995  protected:
21996  llrp_u2_t m_MB;
21997 
22000  public:
22001  static const CFieldDescriptor
22002  s_fdMB;
22004 
22006  inline llrp_u2_t
22007  getMB (void)
22008  {
22009  return m_MB;
22010  }
22011 
22013  inline void
22015  llrp_u2_t value)
22016  {
22017  m_MB = value;
22018  }
22019 
22020 
22021  protected:
22022  llrp_u16_t m_WordPointer;
22023 
22026  public:
22027  static const CFieldDescriptor
22028  s_fdWordPointer;
22030 
22032  inline llrp_u16_t
22034  {
22035  return m_WordPointer;
22036  }
22037 
22039  inline void
22041  llrp_u16_t value)
22042  {
22043  m_WordPointer = value;
22044  }
22045 
22046 
22047  protected:
22048  llrp_u16_t m_WordCount;
22049 
22052  public:
22053  static const CFieldDescriptor
22054  s_fdWordCount;
22056 
22058  inline llrp_u16_t
22060  {
22061  return m_WordCount;
22062  }
22063 
22065  inline void
22067  llrp_u16_t value)
22068  {
22069  m_WordCount = value;
22070  }
22071 
22072 
22073 
22074 };
22075 
22076 
22112 class CC1G2Write : public CParameter
22113 {
22114  public:
22115  CC1G2Write (void);
22116  ~CC1G2Write (void);
22117 
22120 
22121  static const CFieldDescriptor * const
22122  s_apFieldDescriptorTable[];
22123 
22124  static const CTypeDescriptor
22125  s_typeDescriptor;
22126 
22127  void
22128  decodeFields (
22129  CDecoderStream * pDecoderStream);
22130 
22131  void
22132  assimilateSubParameters (
22133  CErrorDetails * pError);
22134 
22135  void
22136  encode (
22137  CEncoderStream * pEncoderStream) const;
22138 
22139 
22140 
22141  static CElement *
22142  s_construct (void);
22143 
22144  static void
22145  s_decodeFields (
22146  CDecoderStream * pDecoderStream,
22147  CElement * pElement);
22149 
22150 
22151  protected:
22152  llrp_u16_t m_OpSpecID;
22153 
22156  public:
22157  static const CFieldDescriptor
22158  s_fdOpSpecID;
22160 
22162  inline llrp_u16_t
22164  {
22165  return m_OpSpecID;
22166  }
22167 
22169  inline void
22171  llrp_u16_t value)
22172  {
22173  m_OpSpecID = value;
22174  }
22175 
22176 
22177  protected:
22178  llrp_u32_t m_AccessPassword;
22179 
22182  public:
22183  static const CFieldDescriptor
22184  s_fdAccessPassword;
22186 
22188  inline llrp_u32_t
22190  {
22191  return m_AccessPassword;
22192  }
22193 
22195  inline void
22197  llrp_u32_t value)
22198  {
22199  m_AccessPassword = value;
22200  }
22201 
22202 
22203  protected:
22204  llrp_u2_t m_MB;
22205 
22208  public:
22209  static const CFieldDescriptor
22210  s_fdMB;
22212 
22214  inline llrp_u2_t
22215  getMB (void)
22216  {
22217  return m_MB;
22218  }
22219 
22221  inline void
22223  llrp_u2_t value)
22224  {
22225  m_MB = value;
22226  }
22227 
22228 
22229  protected:
22230  llrp_u16_t m_WordPointer;
22231 
22234  public:
22235  static const CFieldDescriptor
22236  s_fdWordPointer;
22238 
22240  inline llrp_u16_t
22242  {
22243  return m_WordPointer;
22244  }
22245 
22247  inline void
22249  llrp_u16_t value)
22250  {
22251  m_WordPointer = value;
22252  }
22253 
22254 
22255  protected:
22256  llrp_u16v_t m_WriteData;
22257 
22260  public:
22261  static const CFieldDescriptor
22262  s_fdWriteData;
22264 
22266  inline llrp_u16v_t
22268  {
22269  return m_WriteData;
22270  }
22271 
22273  inline void
22275  llrp_u16v_t value)
22276  {
22277  m_WriteData = value;
22278  }
22279 
22280 
22281 
22282 };
22283 
22284 
22316 class CC1G2Kill : public CParameter
22317 {
22318  public:
22319  CC1G2Kill (void);
22320  ~CC1G2Kill (void);
22321 
22324 
22325  static const CFieldDescriptor * const
22326  s_apFieldDescriptorTable[];
22327 
22328  static const CTypeDescriptor
22329  s_typeDescriptor;
22330 
22331  void
22332  decodeFields (
22333  CDecoderStream * pDecoderStream);
22334 
22335  void
22336  assimilateSubParameters (
22337  CErrorDetails * pError);
22338 
22339  void
22340  encode (
22341  CEncoderStream * pEncoderStream) const;
22342 
22343 
22344 
22345  static CElement *
22346  s_construct (void);
22347 
22348  static void
22349  s_decodeFields (
22350  CDecoderStream * pDecoderStream,
22351  CElement * pElement);
22353 
22354 
22355  protected:
22356  llrp_u16_t m_OpSpecID;
22357 
22360  public:
22361  static const CFieldDescriptor
22362  s_fdOpSpecID;
22364 
22366  inline llrp_u16_t
22368  {
22369  return m_OpSpecID;
22370  }
22371 
22373  inline void
22375  llrp_u16_t value)
22376  {
22377  m_OpSpecID = value;
22378  }
22379 
22380 
22381  protected:
22382  llrp_u32_t m_KillPassword;
22383 
22386  public:
22387  static const CFieldDescriptor
22388  s_fdKillPassword;
22390 
22392  inline llrp_u32_t
22394  {
22395  return m_KillPassword;
22396  }
22397 
22399  inline void
22401  llrp_u32_t value)
22402  {
22403  m_KillPassword = value;
22404  }
22405 
22406 
22407 
22408 };
22409 
22410 
22446 class CC1G2Lock : public CParameter
22447 {
22448  public:
22449  CC1G2Lock (void);
22450  ~CC1G2Lock (void);
22451 
22454 
22455  static const CFieldDescriptor * const
22456  s_apFieldDescriptorTable[];
22457 
22458  static const CTypeDescriptor
22459  s_typeDescriptor;
22460 
22461  void
22462  decodeFields (
22463  CDecoderStream * pDecoderStream);
22464 
22465  void
22466  assimilateSubParameters (
22467  CErrorDetails * pError);
22468 
22469  void
22470  encode (
22471  CEncoderStream * pEncoderStream) const;
22472 
22473 
22474 
22475  static CElement *
22476  s_construct (void);
22477 
22478  static void
22479  s_decodeFields (
22480  CDecoderStream * pDecoderStream,
22481  CElement * pElement);
22483 
22484 
22485  protected:
22486  llrp_u16_t m_OpSpecID;
22487 
22490  public:
22491  static const CFieldDescriptor
22492  s_fdOpSpecID;
22494 
22496  inline llrp_u16_t
22498  {
22499  return m_OpSpecID;
22500  }
22501 
22503  inline void
22505  llrp_u16_t value)
22506  {
22507  m_OpSpecID = value;
22508  }
22509 
22510 
22511  protected:
22512  llrp_u32_t m_AccessPassword;
22513 
22516  public:
22517  static const CFieldDescriptor
22518  s_fdAccessPassword;
22520 
22522  inline llrp_u32_t
22524  {
22525  return m_AccessPassword;
22526  }
22527 
22529  inline void
22531  llrp_u32_t value)
22532  {
22533  m_AccessPassword = value;
22534  }
22535 
22536 
22537 
22538  protected:
22539  std::list<CC1G2LockPayload *> m_listC1G2LockPayload;
22540 
22541  public:
22543  inline std::list<CC1G2LockPayload *>::iterator
22545  {
22546  return m_listC1G2LockPayload.begin();
22547  }
22548 
22550  inline std::list<CC1G2LockPayload *>::iterator
22552  {
22553  return m_listC1G2LockPayload.end();
22554  }
22555 
22557  inline void
22559  {
22560  clearSubParameterList ((tListOfParameters *) &m_listC1G2LockPayload);
22561  }
22562 
22564  inline int
22566  {
22567  return (int) (m_listC1G2LockPayload.size());
22568  }
22569 
22570  EResultCode
22572  addC1G2LockPayload (
22573  CC1G2LockPayload * pValue);
22574 
22575 
22576 };
22577 
22578 
22610 class CC1G2LockPayload : public CParameter
22611 {
22612  public:
22613  CC1G2LockPayload (void);
22614  ~CC1G2LockPayload (void);
22615 
22618 
22619  static const CFieldDescriptor * const
22620  s_apFieldDescriptorTable[];
22621 
22622  static const CTypeDescriptor
22623  s_typeDescriptor;
22624 
22625  void
22626  decodeFields (
22627  CDecoderStream * pDecoderStream);
22628 
22629  void
22630  assimilateSubParameters (
22631  CErrorDetails * pError);
22632 
22633  void
22634  encode (
22635  CEncoderStream * pEncoderStream) const;
22636 
22637 
22638 
22639  static CElement *
22640  s_construct (void);
22641 
22642  static void
22643  s_decodeFields (
22644  CDecoderStream * pDecoderStream,
22645  CElement * pElement);
22647 
22648 
22649  protected:
22650  EC1G2LockPrivilege m_ePrivilege;
22651 
22654  public:
22655  static const CFieldDescriptor
22656  s_fdPrivilege;
22658 
22660  inline EC1G2LockPrivilege
22662  {
22663  return m_ePrivilege;
22664  }
22665 
22667  inline void
22669  EC1G2LockPrivilege value)
22670  {
22671  m_ePrivilege = value;
22672  }
22673 
22674 
22675  protected:
22676  EC1G2LockDataField m_eDataField;
22677 
22680  public:
22681  static const CFieldDescriptor
22682  s_fdDataField;
22684 
22686  inline EC1G2LockDataField
22688  {
22689  return m_eDataField;
22690  }
22691 
22693  inline void
22695  EC1G2LockDataField value)
22696  {
22697  m_eDataField = value;
22698  }
22699 
22700 
22701 
22702 };
22703 
22704 
22747 class CC1G2BlockErase : public CParameter
22748 {
22749  public:
22750  CC1G2BlockErase (void);
22751  ~CC1G2BlockErase (void);
22752 
22755 
22756  static const CFieldDescriptor * const
22757  s_apFieldDescriptorTable[];
22758 
22759  static const CTypeDescriptor
22760  s_typeDescriptor;
22761 
22762  void
22763  decodeFields (
22764  CDecoderStream * pDecoderStream);
22765 
22766  void
22767  assimilateSubParameters (
22768  CErrorDetails * pError);
22769 
22770  void
22771  encode (
22772  CEncoderStream * pEncoderStream) const;
22773 
22774 
22775 
22776  static CElement *
22777  s_construct (void);
22778 
22779  static void
22780  s_decodeFields (
22781  CDecoderStream * pDecoderStream,
22782  CElement * pElement);
22784 
22785 
22786  protected:
22787  llrp_u16_t m_OpSpecID;
22788 
22791  public:
22792  static const CFieldDescriptor
22793  s_fdOpSpecID;
22795 
22797  inline llrp_u16_t
22799  {
22800  return m_OpSpecID;
22801  }
22802 
22804  inline void
22806  llrp_u16_t value)
22807  {
22808  m_OpSpecID = value;
22809  }
22810 
22811 
22812  protected:
22813  llrp_u32_t m_AccessPassword;
22814 
22817  public:
22818  static const CFieldDescriptor
22819  s_fdAccessPassword;
22821 
22823  inline llrp_u32_t
22825  {
22826  return m_AccessPassword;
22827  }
22828 
22830  inline void
22832  llrp_u32_t value)
22833  {
22834  m_AccessPassword = value;
22835  }
22836 
22837 
22838  protected:
22839  llrp_u2_t m_MB;
22840 
22843  public:
22844  static const CFieldDescriptor
22845  s_fdMB;
22847 
22849  inline llrp_u2_t
22850  getMB (void)
22851  {
22852  return m_MB;
22853  }
22854 
22856  inline void
22858  llrp_u2_t value)
22859  {
22860  m_MB = value;
22861  }
22862 
22863 
22864  protected:
22865  llrp_u16_t m_WordPointer;
22866 
22869  public:
22870  static const CFieldDescriptor
22871  s_fdWordPointer;
22873 
22875  inline llrp_u16_t
22877  {
22878  return m_WordPointer;
22879  }
22880 
22882  inline void
22884  llrp_u16_t value)
22885  {
22886  m_WordPointer = value;
22887  }
22888 
22889 
22890  protected:
22891  llrp_u16_t m_WordCount;
22892 
22895  public:
22896  static const CFieldDescriptor
22897  s_fdWordCount;
22899 
22901  inline llrp_u16_t
22903  {
22904  return m_WordCount;
22905  }
22906 
22908  inline void
22910  llrp_u16_t value)
22911  {
22912  m_WordCount = value;
22913  }
22914 
22915 
22916 
22917 };
22918 
22919 
22962 class CC1G2BlockWrite : public CParameter
22963 {
22964  public:
22965  CC1G2BlockWrite (void);
22966  ~CC1G2BlockWrite (void);
22967 
22970 
22971  static const CFieldDescriptor * const
22972  s_apFieldDescriptorTable[];
22973 
22974  static const CTypeDescriptor
22975  s_typeDescriptor;
22976 
22977  void
22978  decodeFields (
22979  CDecoderStream * pDecoderStream);
22980 
22981  void
22982  assimilateSubParameters (
22983  CErrorDetails * pError);
22984 
22985  void
22986  encode (
22987  CEncoderStream * pEncoderStream) const;
22988 
22989 
22990 
22991  static CElement *
22992  s_construct (void);
22993 
22994  static void
22995  s_decodeFields (
22996  CDecoderStream * pDecoderStream,
22997  CElement * pElement);
22999 
23000 
23001  protected:
23002  llrp_u16_t m_OpSpecID;
23003 
23006  public:
23007  static const CFieldDescriptor
23008  s_fdOpSpecID;
23010 
23012  inline llrp_u16_t
23014  {
23015  return m_OpSpecID;
23016  }
23017 
23019  inline void
23021  llrp_u16_t value)
23022  {
23023  m_OpSpecID = value;
23024  }
23025 
23026 
23027  protected:
23028  llrp_u32_t m_AccessPassword;
23029 
23032  public:
23033  static const CFieldDescriptor
23034  s_fdAccessPassword;
23036 
23038  inline llrp_u32_t
23040  {
23041  return m_AccessPassword;
23042  }
23043 
23045  inline void
23047  llrp_u32_t value)
23048  {
23049  m_AccessPassword = value;
23050  }
23051 
23052 
23053  protected:
23054  llrp_u2_t m_MB;
23055 
23058  public:
23059  static const CFieldDescriptor
23060  s_fdMB;
23062 
23064  inline llrp_u2_t
23065  getMB (void)
23066  {
23067  return m_MB;
23068  }
23069 
23071  inline void
23073  llrp_u2_t value)
23074  {
23075  m_MB = value;
23076  }
23077 
23078 
23079  protected:
23080  llrp_u16_t m_WordPointer;
23081 
23084  public:
23085  static const CFieldDescriptor
23086  s_fdWordPointer;
23088 
23090  inline llrp_u16_t
23092  {
23093  return m_WordPointer;
23094  }
23095 
23097  inline void
23099  llrp_u16_t value)
23100  {
23101  m_WordPointer = value;
23102  }
23103 
23104 
23105  protected:
23106  llrp_u16v_t m_WriteData;
23107 
23110  public:
23111  static const CFieldDescriptor
23112  s_fdWriteData;
23114 
23116  inline llrp_u16v_t
23118  {
23119  return m_WriteData;
23120  }
23121 
23123  inline void
23125  llrp_u16v_t value)
23126  {
23127  m_WriteData = value;
23128  }
23129 
23130 
23131 
23132 };
23133 
23134 
23167 class CC1G2EPCMemorySelector : public CParameter
23168 {
23169  public:
23170  CC1G2EPCMemorySelector (void);
23171  ~CC1G2EPCMemorySelector (void);
23172 
23175 
23176  static const CFieldDescriptor * const
23177  s_apFieldDescriptorTable[];
23178 
23179  static const CTypeDescriptor
23180  s_typeDescriptor;
23181 
23182  void
23183  decodeFields (
23184  CDecoderStream * pDecoderStream);
23185 
23186  void
23187  assimilateSubParameters (
23188  CErrorDetails * pError);
23189 
23190  void
23191  encode (
23192  CEncoderStream * pEncoderStream) const;
23193 
23194 
23195 
23196  static CElement *
23197  s_construct (void);
23198 
23199  static void
23200  s_decodeFields (
23201  CDecoderStream * pDecoderStream,
23202  CElement * pElement);
23204 
23205 
23206  protected:
23207  llrp_u1_t m_EnableCRC;
23208 
23211  public:
23212  static const CFieldDescriptor
23213  s_fdEnableCRC;
23215 
23217  inline llrp_u1_t
23219  {
23220  return m_EnableCRC;
23221  }
23222 
23224  inline void
23226  llrp_u1_t value)
23227  {
23228  m_EnableCRC = value;
23229  }
23230 
23231 
23232  protected:
23233  llrp_u1_t m_EnablePCBits;
23234 
23237  public:
23238  static const CFieldDescriptor
23239  s_fdEnablePCBits;
23241 
23243  inline llrp_u1_t
23245  {
23246  return m_EnablePCBits;
23247  }
23248 
23250  inline void
23252  llrp_u1_t value)
23253  {
23254  m_EnablePCBits = value;
23255  }
23256 
23257 
23258 
23259 };
23260 
23261 
23292 class CC1G2_PC : public CParameter
23293 {
23294  public:
23295  CC1G2_PC (void);
23296  ~CC1G2_PC (void);
23297 
23300 
23301  static const CFieldDescriptor * const
23302  s_apFieldDescriptorTable[];
23303 
23304  static const CTypeDescriptor
23305  s_typeDescriptor;
23306 
23307  void
23308  decodeFields (
23309  CDecoderStream * pDecoderStream);
23310 
23311  void
23312  assimilateSubParameters (
23313  CErrorDetails * pError);
23314 
23315  void
23316  encode (
23317  CEncoderStream * pEncoderStream) const;
23318 
23319 
23320 
23321  static CElement *
23322  s_construct (void);
23323 
23324  static void
23325  s_decodeFields (
23326  CDecoderStream * pDecoderStream,
23327  CElement * pElement);
23329 
23330 
23331  protected:
23332  llrp_u16_t m_PC_Bits;
23333 
23336  public:
23337  static const CFieldDescriptor
23338  s_fdPC_Bits;
23340 
23342  inline llrp_u16_t
23343  getPC_Bits (void)
23344  {
23345  return m_PC_Bits;
23346  }
23347 
23349  inline void
23351  llrp_u16_t value)
23352  {
23353  m_PC_Bits = value;
23354  }
23355 
23356 
23357 
23358 };
23359 
23360 
23391 class CC1G2_CRC : public CParameter
23392 {
23393  public:
23394  CC1G2_CRC (void);
23395  ~CC1G2_CRC (void);
23396 
23399 
23400  static const CFieldDescriptor * const
23401  s_apFieldDescriptorTable[];
23402 
23403  static const CTypeDescriptor
23404  s_typeDescriptor;
23405 
23406  void
23407  decodeFields (
23408  CDecoderStream * pDecoderStream);
23409 
23410  void
23411  assimilateSubParameters (
23412  CErrorDetails * pError);
23413 
23414  void
23415  encode (
23416  CEncoderStream * pEncoderStream) const;
23417 
23418 
23419 
23420  static CElement *
23421  s_construct (void);
23422 
23423  static void
23424  s_decodeFields (
23425  CDecoderStream * pDecoderStream,
23426  CElement * pElement);
23428 
23429 
23430  protected:
23431  llrp_u16_t m_CRC;
23432 
23435  public:
23436  static const CFieldDescriptor
23437  s_fdCRC;
23439 
23441  inline llrp_u16_t
23442  getCRC (void)
23443  {
23444  return m_CRC;
23445  }
23446 
23448  inline void
23450  llrp_u16_t value)
23451  {
23452  m_CRC = value;
23453  }
23454 
23455 
23456 
23457 };
23458 
23459 
23484 class CC1G2SingulationDetails : public CParameter
23485 {
23486  public:
23487  CC1G2SingulationDetails (void);
23488  ~CC1G2SingulationDetails (void);
23489 
23492 
23493  static const CFieldDescriptor * const
23494  s_apFieldDescriptorTable[];
23495 
23496  static const CTypeDescriptor
23497  s_typeDescriptor;
23498 
23499  void
23500  decodeFields (
23501  CDecoderStream * pDecoderStream);
23502 
23503  void
23504  assimilateSubParameters (
23505  CErrorDetails * pError);
23506 
23507  void
23508  encode (
23509  CEncoderStream * pEncoderStream) const;
23510 
23511 
23512 
23513  static CElement *
23514  s_construct (void);
23515 
23516  static void
23517  s_decodeFields (
23518  CDecoderStream * pDecoderStream,
23519  CElement * pElement);
23521 
23522 
23523  protected:
23524  llrp_u16_t m_NumCollisionSlots;
23525 
23528  public:
23529  static const CFieldDescriptor
23530  s_fdNumCollisionSlots;
23532 
23534  inline llrp_u16_t
23536  {
23537  return m_NumCollisionSlots;
23538  }
23539 
23541  inline void
23543  llrp_u16_t value)
23544  {
23545  m_NumCollisionSlots = value;
23546  }
23547 
23548 
23549  protected:
23550  llrp_u16_t m_NumEmptySlots;
23551 
23554  public:
23555  static const CFieldDescriptor
23556  s_fdNumEmptySlots;
23558 
23560  inline llrp_u16_t
23562  {
23563  return m_NumEmptySlots;
23564  }
23565 
23567  inline void
23569  llrp_u16_t value)
23570  {
23571  m_NumEmptySlots = value;
23572  }
23573 
23574 
23575 
23576 };
23577 
23578 
23611 class CC1G2ReadOpSpecResult : public CParameter
23612 {
23613  public:
23614  CC1G2ReadOpSpecResult (void);
23615  ~CC1G2ReadOpSpecResult (void);
23616 
23619 
23620  static const CFieldDescriptor * const
23621  s_apFieldDescriptorTable[];
23622 
23623  static const CTypeDescriptor
23624  s_typeDescriptor;
23625 
23626  void
23627  decodeFields (
23628  CDecoderStream * pDecoderStream);
23629 
23630  void
23631  assimilateSubParameters (
23632  CErrorDetails * pError);
23633 
23634  void
23635  encode (
23636  CEncoderStream * pEncoderStream) const;
23637 
23638 
23639 
23640  static CElement *
23641  s_construct (void);
23642 
23643  static void
23644  s_decodeFields (
23645  CDecoderStream * pDecoderStream,
23646  CElement * pElement);
23648 
23649 
23650  protected:
23651  EC1G2ReadResultType m_eResult;
23652 
23655  public:
23656  static const CFieldDescriptor
23657  s_fdResult;
23659 
23661  inline EC1G2ReadResultType
23662  getResult (void)
23663  {
23664  return m_eResult;
23665  }
23666 
23668  inline void
23670  EC1G2ReadResultType value)
23671  {
23672  m_eResult = value;
23673  }
23674 
23675 
23676  protected:
23677  llrp_u16_t m_OpSpecID;
23678 
23681  public:
23682  static const CFieldDescriptor
23683  s_fdOpSpecID;
23685 
23687  inline llrp_u16_t
23689  {
23690  return m_OpSpecID;
23691  }
23692 
23694  inline void
23696  llrp_u16_t value)
23697  {
23698  m_OpSpecID = value;
23699  }
23700 
23701 
23702  protected:
23703  llrp_u16v_t m_ReadData;
23704 
23707  public:
23708  static const CFieldDescriptor
23709  s_fdReadData;
23711 
23713  inline llrp_u16v_t
23715  {
23716  return m_ReadData;
23717  }
23718 
23720  inline void
23722  llrp_u16v_t value)
23723  {
23724  m_ReadData = value;
23725  }
23726 
23727 
23728 
23729 };
23730 
23731 
23769 class CC1G2WriteOpSpecResult : public CParameter
23770 {
23771  public:
23772  CC1G2WriteOpSpecResult (void);
23773  ~CC1G2WriteOpSpecResult (void);
23774 
23777 
23778  static const CFieldDescriptor * const
23779  s_apFieldDescriptorTable[];
23780 
23781  static const CTypeDescriptor
23782  s_typeDescriptor;
23783 
23784  void
23785  decodeFields (
23786  CDecoderStream * pDecoderStream);
23787 
23788  void
23789  assimilateSubParameters (
23790  CErrorDetails * pError);
23791 
23792  void
23793  encode (
23794  CEncoderStream * pEncoderStream) const;
23795 
23796 
23797 
23798  static CElement *
23799  s_construct (void);
23800 
23801  static void
23802  s_decodeFields (
23803  CDecoderStream * pDecoderStream,
23804  CElement * pElement);
23806 
23807 
23808  protected:
23809  EC1G2WriteResultType m_eResult;
23810 
23813  public:
23814  static const CFieldDescriptor
23815  s_fdResult;
23817 
23819  inline EC1G2WriteResultType
23820  getResult (void)
23821  {
23822  return m_eResult;
23823  }
23824 
23826  inline void
23828  EC1G2WriteResultType value)
23829  {
23830  m_eResult = value;
23831  }
23832 
23833 
23834  protected:
23835  llrp_u16_t m_OpSpecID;
23836 
23839  public:
23840  static const CFieldDescriptor
23841  s_fdOpSpecID;
23843 
23845  inline llrp_u16_t
23847  {
23848  return m_OpSpecID;
23849  }
23850 
23852  inline void
23854  llrp_u16_t value)
23855  {
23856  m_OpSpecID = value;
23857  }
23858 
23859 
23860  protected:
23861  llrp_u16_t m_NumWordsWritten;
23862 
23865  public:
23866  static const CFieldDescriptor
23867  s_fdNumWordsWritten;
23869 
23871  inline llrp_u16_t
23873  {
23874  return m_NumWordsWritten;
23875  }
23876 
23878  inline void
23880  llrp_u16_t value)
23881  {
23882  m_NumWordsWritten = value;
23883  }
23884 
23885 
23886 
23887 };
23888 
23889 
23919 class CC1G2KillOpSpecResult : public CParameter
23920 {
23921  public:
23922  CC1G2KillOpSpecResult (void);
23923  ~CC1G2KillOpSpecResult (void);
23924 
23927 
23928  static const CFieldDescriptor * const
23929  s_apFieldDescriptorTable[];
23930 
23931  static const CTypeDescriptor
23932  s_typeDescriptor;
23933 
23934  void
23935  decodeFields (
23936  CDecoderStream * pDecoderStream);
23937 
23938  void
23939  assimilateSubParameters (
23940  CErrorDetails * pError);
23941 
23942  void
23943  encode (
23944  CEncoderStream * pEncoderStream) const;
23945 
23946 
23947 
23948  static CElement *
23949  s_construct (void);
23950 
23951  static void
23952  s_decodeFields (
23953  CDecoderStream * pDecoderStream,
23954  CElement * pElement);
23956 
23957 
23958  protected:
23959  EC1G2KillResultType m_eResult;
23960 
23963  public:
23964  static const CFieldDescriptor
23965  s_fdResult;
23967 
23969  inline EC1G2KillResultType
23970  getResult (void)
23971  {
23972  return m_eResult;
23973  }
23974 
23976  inline void
23978  EC1G2KillResultType value)
23979  {
23980  m_eResult = value;
23981  }
23982 
23983 
23984  protected:
23985  llrp_u16_t m_OpSpecID;
23986 
23989  public:
23990  static const CFieldDescriptor
23991  s_fdOpSpecID;
23993 
23995  inline llrp_u16_t
23997  {
23998  return m_OpSpecID;
23999  }
24000 
24002  inline void
24004  llrp_u16_t value)
24005  {
24006  m_OpSpecID = value;
24007  }
24008 
24009 
24010 
24011 };
24012 
24013 
24045 class CC1G2LockOpSpecResult : public CParameter
24046 {
24047  public:
24048  CC1G2LockOpSpecResult (void);
24049  ~CC1G2LockOpSpecResult (void);
24050 
24053 
24054  static const CFieldDescriptor * const
24055  s_apFieldDescriptorTable[];
24056 
24057  static const CTypeDescriptor
24058  s_typeDescriptor;
24059 
24060  void
24061  decodeFields (
24062  CDecoderStream * pDecoderStream);
24063 
24064  void
24065  assimilateSubParameters (
24066  CErrorDetails * pError);
24067 
24068  void
24069  encode (
24070  CEncoderStream * pEncoderStream) const;
24071 
24072 
24073 
24074  static CElement *
24075  s_construct (void);
24076 
24077  static void
24078  s_decodeFields (
24079  CDecoderStream * pDecoderStream,
24080  CElement * pElement);
24082 
24083 
24084  protected:
24085  EC1G2LockResultType m_eResult;
24086 
24089  public:
24090  static const CFieldDescriptor
24091  s_fdResult;
24093 
24095  inline EC1G2LockResultType
24096  getResult (void)
24097  {
24098  return m_eResult;
24099  }
24100 
24102  inline void
24104  EC1G2LockResultType value)
24105  {
24106  m_eResult = value;
24107  }
24108 
24109 
24110  protected:
24111  llrp_u16_t m_OpSpecID;
24112 
24115  public:
24116  static const CFieldDescriptor
24117  s_fdOpSpecID;
24119 
24121  inline llrp_u16_t
24123  {
24124  return m_OpSpecID;
24125  }
24126 
24128  inline void
24130  llrp_u16_t value)
24131  {
24132  m_OpSpecID = value;
24133  }
24134 
24135 
24136 
24137 };
24138 
24139 
24178 class CC1G2BlockEraseOpSpecResult : public CParameter
24179 {
24180  public:
24183 
24186 
24187  static const CFieldDescriptor * const
24188  s_apFieldDescriptorTable[];
24189 
24190  static const CTypeDescriptor
24191  s_typeDescriptor;
24192 
24193  void
24194  decodeFields (
24195  CDecoderStream * pDecoderStream);
24196 
24197  void
24198  assimilateSubParameters (
24199  CErrorDetails * pError);
24200 
24201  void
24202  encode (
24203  CEncoderStream * pEncoderStream) const;
24204 
24205 
24206 
24207  static CElement *
24208  s_construct (void);
24209 
24210  static void
24211  s_decodeFields (
24212  CDecoderStream * pDecoderStream,
24213  CElement * pElement);
24215 
24216 
24217  protected:
24218  EC1G2BlockEraseResultType m_eResult;
24219 
24222  public:
24223  static const CFieldDescriptor
24224  s_fdResult;
24226 
24228  inline EC1G2BlockEraseResultType
24229  getResult (void)
24230  {
24231  return m_eResult;
24232  }
24233 
24235  inline void
24237  EC1G2BlockEraseResultType value)
24238  {
24239  m_eResult = value;
24240  }
24241 
24242 
24243  protected:
24244  llrp_u16_t m_OpSpecID;
24245 
24248  public:
24249  static const CFieldDescriptor
24250  s_fdOpSpecID;
24252 
24254  inline llrp_u16_t
24256  {
24257  return m_OpSpecID;
24258  }
24259 
24261  inline void
24263  llrp_u16_t value)
24264  {
24265  m_OpSpecID = value;
24266  }
24267 
24268 
24269 
24270 };
24271 
24272 
24312 class CC1G2BlockWriteOpSpecResult : public CParameter
24313 {
24314  public:
24317 
24320 
24321  static const CFieldDescriptor * const
24322  s_apFieldDescriptorTable[];
24323 
24324  static const CTypeDescriptor
24325  s_typeDescriptor;
24326 
24327  void
24328  decodeFields (
24329  CDecoderStream * pDecoderStream);
24330 
24331  void
24332  assimilateSubParameters (
24333  CErrorDetails * pError);
24334 
24335  void
24336  encode (
24337  CEncoderStream * pEncoderStream) const;
24338 
24339 
24340 
24341  static CElement *
24342  s_construct (void);
24343 
24344  static void
24345  s_decodeFields (
24346  CDecoderStream * pDecoderStream,
24347  CElement * pElement);
24349 
24350 
24351  protected:
24352  EC1G2BlockWriteResultType m_eResult;
24353 
24356  public:
24357  static const CFieldDescriptor
24358  s_fdResult;
24360 
24362  inline EC1G2BlockWriteResultType
24363  getResult (void)
24364  {
24365  return m_eResult;
24366  }
24367 
24369  inline void
24371  EC1G2BlockWriteResultType value)
24372  {
24373  m_eResult = value;
24374  }
24375 
24376 
24377  protected:
24378  llrp_u16_t m_OpSpecID;
24379 
24382  public:
24383  static const CFieldDescriptor
24384  s_fdOpSpecID;
24386 
24388  inline llrp_u16_t
24390  {
24391  return m_OpSpecID;
24392  }
24393 
24395  inline void
24397  llrp_u16_t value)
24398  {
24399  m_OpSpecID = value;
24400  }
24401 
24402 
24403  protected:
24404  llrp_u16_t m_NumWordsWritten;
24405 
24408  public:
24409  static const CFieldDescriptor
24410  s_fdNumWordsWritten;
24412 
24414  inline llrp_u16_t
24416  {
24417  return m_NumWordsWritten;
24418  }
24419 
24421  inline void
24423  llrp_u16_t value)
24424  {
24425  m_NumWordsWritten = value;
24426  }
24427 
24428 
24429 
24430 };
24431 
24432 
24435 class CSpecParameter
24436 {
24439  public:
24440  static const CTypeDescriptor
24441  s_typeDescriptor;
24442 
24443  static llrp_bool_t
24444  isMember (
24445  CParameter * pParameter);
24447 
24448 };
24449 
24450 class CAccessCommandOpSpec
24451 {
24454  public:
24455  static const CTypeDescriptor
24456  s_typeDescriptor;
24457 
24458  static llrp_bool_t
24459  isMember (
24460  CParameter * pParameter);
24462 
24463 };
24464 
24465 class CAccessCommandOpSpecResult
24466 {
24469  public:
24470  static const CTypeDescriptor
24471  s_typeDescriptor;
24472 
24473  static llrp_bool_t
24474  isMember (
24475  CParameter * pParameter);
24477 
24478 };
24479 
24480 class CEPCParameter
24481 {
24484  public:
24485  static const CTypeDescriptor
24486  s_typeDescriptor;
24487 
24488  static llrp_bool_t
24489  isMember (
24490  CParameter * pParameter);
24492 
24493 };
24494 
24495 class CTimestamp
24496 {
24499  public:
24500  static const CTypeDescriptor
24501  s_typeDescriptor;
24502 
24503  static llrp_bool_t
24504  isMember (
24505  CParameter * pParameter);
24507 
24508 };
24509 
24510 class CC1G2OpSpec
24511 {
24514  public:
24515  static const CTypeDescriptor
24516  s_typeDescriptor;
24517 
24518  static llrp_bool_t
24519  isMember (
24520  CParameter * pParameter);
24522 
24523 };
24524 
24525 class CAirProtocolLLRPCapabilities
24526 {
24529  public:
24530  static const CTypeDescriptor
24531  s_typeDescriptor;
24532 
24533  static llrp_bool_t
24534  isMember (
24535  CParameter * pParameter);
24537 
24538 };
24539 
24540 class CAirProtocolUHFRFModeTable
24541 {
24544  public:
24545  static const CTypeDescriptor
24546  s_typeDescriptor;
24547 
24548  static llrp_bool_t
24549  isMember (
24550  CParameter * pParameter);
24552 
24553 };
24554 
24555 class CAirProtocolInventoryCommandSettings
24556 {
24559  public:
24560  static const CTypeDescriptor
24561  s_typeDescriptor;
24562 
24563  static llrp_bool_t
24564  isMember (
24565  CParameter * pParameter);
24567 
24568 };
24569 
24570 class CAirProtocolTagSpec
24571 {
24574  public:
24575  static const CTypeDescriptor
24576  s_typeDescriptor;
24577 
24578  static llrp_bool_t
24579  isMember (
24580  CParameter * pParameter);
24582 
24583 };
24584 
24585 class CAirProtocolOpSpec
24586 {
24589  public:
24590  static const CTypeDescriptor
24591  s_typeDescriptor;
24592 
24593  static llrp_bool_t
24594  isMember (
24595  CParameter * pParameter);
24597 
24598 };
24599 
24600 class CAirProtocolEPCMemorySelector
24601 {
24604  public:
24605  static const CTypeDescriptor
24606  s_typeDescriptor;
24607 
24608  static llrp_bool_t
24609  isMember (
24610  CParameter * pParameter);
24612 
24613 };
24614 
24615 class CAirProtocolTagData
24616 {
24619  public:
24620  static const CTypeDescriptor
24621  s_typeDescriptor;
24622 
24623  static llrp_bool_t
24624  isMember (
24625  CParameter * pParameter);
24627 
24628 };
24629 
24630 class CAirProtocolSingulationDetails
24631 {
24634  public:
24635  static const CTypeDescriptor
24636  s_typeDescriptor;
24637 
24638  static llrp_bool_t
24639  isMember (
24640  CParameter * pParameter);
24642 
24643 };
24644 
24645 
24657 extern void
24659  CTypeRegistry * pTypeRegistry);
llrp_u16_t getN(void)
Get accessor functions for the LLRP N field.
void setEnableFirstSeenTimestamp(llrp_u1_t value)
Set accessor functions for the LLRP EnableFirstSeenTimestamp field.
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
llrp_utf8v_t getMessage(void)
Get accessor functions for the LLRP Message field.
Class Definition CERROR_MESSAGE for LLRP message ERROR_MESSAGE.
std::list< CAccessSpec * >::iterator beginAccessSpec(void)
Returns the first element of the AccessSpec sub-parameter list.
void setRequestedData(EGetReaderConfigRequestedData value)
Set accessor functions for the LLRP RequestedData field.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
llrp_u16v_t getWriteData(void)
Get accessor functions for the LLRP WriteData field.
CPeakRSSI * getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI sub-parameter.
std::list< CParameter * >::iterator endAirProtocolTagData(void)
Returns the last element of the AirProtocolTagData sub-parameter list.
Class Definition CConnectionAttemptEvent for LLRP parameter ConnectionAttemptEvent.
void setEndFrequency(llrp_u32_t value)
Set accessor functions for the LLRP EndFrequency field.
llrp_bytesToEnd_t getData(void)
Get accessor functions for the LLRP Data field.
std::list< CParameter * >::iterator beginAirProtocolEPCMemorySelector(void)
Returns the first element of the AirProtocolEPCMemorySelector sub-parameter list. ...
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u16_t getCRC(void)
Get accessor functions for the LLRP CRC field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
void setEnableCRC(llrp_u1_t value)
Set accessor functions for the LLRP EnableCRC field.
void setPeriodicTriggerValue(llrp_u32_t value)
Set accessor functions for the LLRP PeriodicTriggerValue field.
void setFrequency(llrp_u32_t value)
Set accessor functions for the LLRP Frequency field.
Class Definition CDELETE_ACCESSSPEC_RESPONSE for LLRP message DELETE_ACCESSSPEC_RESPONSE.
void setStatusCode(EStatusCode value)
Set accessor functions for the LLRP StatusCode field.
void setHopping(llrp_u1_t value)
Set accessor functions for the LLRP Hopping field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
EC1G2WriteResultType getResult(void)
Get accessor functions for the LLRP Result field.
void clearTagReportData(void)
Clears the LLRP TagReportData sub-parameter list.
CAntennaID * getAntennaID(void)
Get accessor functions for the LLRP AntennaID sub-parameter.
void setGPIPortNumber(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNumber field.
llrp_u32_t getVendorIdentifier(void)
Get accessor functions for the LLRP VendorIdentifier field.
EAccessReportTriggerType getAccessReportTrigger(void)
Get accessor functions for the LLRP AccessReportTrigger field.
std::list< CTransmitPowerLevelTableEntry * >::iterator beginTransmitPowerLevelTableEntry(void)
Returns the first element of the TransmitPowerLevelTableEntry sub-parameter list. ...
CTagObservationTrigger * getTagObservationTrigger(void)
Get accessor functions for the LLRP TagObservationTrigger sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CPeakRSSI for LLRP parameter PeakRSSI.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
std::list< CParameter * >::iterator endSpecParameter(void)
Returns the last element of the SpecParameter sub-parameter list.
void setReceiveSensitivityValue(llrp_s16_t value)
Set accessor functions for the LLRP ReceiveSensitivityValue field.
Class Definition CFirstSeenTimestampUTC for LLRP parameter FirstSeenTimestampUTC. ...
Class Definition CADD_ACCESSSPEC_RESPONSE for LLRP message ADD_ACCESSSPEC_RESPONSE.
std::list< CGPOWriteData * >::iterator beginGPOWriteData(void)
Returns the first element of the GPOWriteData sub-parameter list.
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
Class Definition CLastSeenTimestampUptime for LLRP parameter LastSeenTimestampUptime.
Class Definition CSpecIndex for LLRP parameter SpecIndex.
CC1G2TagInventoryStateUnawareFilterAction * getC1G2TagInventoryStateUnawareFilterAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateUnawareFilterAction sub-parameter.
void setCanDoTagInventoryStateAwareSingulation(llrp_u1_t value)
Set accessor functions for the LLRP CanDoTagInventoryStateAwareSingulation field. ...
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
llrp_u16_t getMaxNumSelectFiltersPerQuery(void)
Get accessor functions for the LLRP MaxNumSelectFiltersPerQuery field.
Class Definition CPerAntennaReceiveSensitivityRange for LLRP parameter PerAntennaReceiveSensitivityRa...
Class Definition CClientRequestOpSpecResult for LLRP parameter ClientRequestOpSpecResult.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
int countPerAntennaReceiveSensitivityRange(void)
Count of the LLRP PerAntennaReceiveSensitivityRange sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endAirProtocolOpSpec(void)
Returns the last element of the AirProtocolOpSpec sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
EAccessSpecState getCurrentState(void)
Get accessor functions for the LLRP CurrentState field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CAISpecEvent * getAISpecEvent(void)
Get accessor functions for the LLRP AISpecEvent sub-parameter.
EStatusCode getErrorCode(void)
Get accessor functions for the LLRP ErrorCode field.
llrp_u32_t getPreemptingROSpecID(void)
Get accessor functions for the LLRP PreemptingROSpecID field.
CROSpecEvent * getROSpecEvent(void)
Get accessor functions for the LLRP ROSpecEvent sub-parameter.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
llrp_u1_t getHasUTCClockCapability(void)
Get accessor functions for the LLRP HasUTCClockCapability field.
int countTransmitPowerLevelTableEntry(void)
Count of the LLRP TransmitPowerLevelTableEntry sub-parameter list.
llrp_u1_t getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent field.
void setErrorCode(EStatusCode value)
Set accessor functions for the LLRP ErrorCode field.
llrp_u16_t getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex field.
void clearReceiveSensitivityTableEntry(void)
Clears the LLRP ReceiveSensitivityTableEntry sub-parameter list.
llrp_s16_t getReceiveSensitivityValue(void)
Get accessor functions for the LLRP ReceiveSensitivityValue field.
void setDeviceManufacturerName(llrp_u32_t value)
Set accessor functions for the LLRP DeviceManufacturerName field.
Class Definition CC1G2TagInventoryStateAwareSingulationAction for LLRP parameter C1G2TagInventoryStat...
Class Definition CIdentification for LLRP parameter Identification.
void setKillPassword(llrp_u32_t value)
Set accessor functions for the LLRP KillPassword field.
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
void setPIEValue(llrp_u32_t value)
Set accessor functions for the LLRP PIEValue field.
CRFReceiver * getRFReceiver(void)
Get accessor functions for the LLRP RFReceiver sub-parameter.
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
void setHopTableID(llrp_u8_t value)
Set accessor functions for the LLRP HopTableID field.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
Class Definition CEPC_96 for LLRP parameter EPC_96.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countGPIPortCurrentState(void)
Count of the LLRP GPIPortCurrentState sub-parameter list.
llrp_u32_t getVendorIdentifier(void)
Get accessor functions for the LLRP VendorIdentifier field.
llrp_u8_t getMessageSubtype(void)
Get accessor functions for the LLRP MessageSubtype field.
llrp_u32_t getMaxNumSpecsPerROSpec(void)
Get accessor functions for the LLRP MaxNumSpecsPerROSpec field.
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Class Definition CC1G2Write for LLRP parameter C1G2Write.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Class Definition CTagObservationTrigger for LLRP parameter TagObservationTrigger. ...
void setReadData(llrp_u16v_t value)
Set accessor functions for the LLRP ReadData field.
Class Definition CC1G2UHFRFModeTable for LLRP parameter C1G2UHFRFModeTable.
std::list< CTransmitPowerLevelTableEntry * >::iterator endTransmitPowerLevelTableEntry(void)
Returns the last element of the TransmitPowerLevelTableEntry sub-parameter list.
CRFTransmitter * getRFTransmitter(void)
Get accessor functions for the LLRP RFTransmitter sub-parameter.
CAccessSpec * getAccessSpec(void)
Get accessor functions for the LLRP AccessSpec sub-parameter.
EROSpecEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Class Definition CUptime for LLRP parameter Uptime.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Class Definition CConnectionCloseEvent for LLRP parameter ConnectionCloseEvent.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
std::list< CGPIPortCurrentState * >::iterator endGPIPortCurrentState(void)
Returns the last element of the GPIPortCurrentState sub-parameter list.
Class Definition CTransmitPowerLevelTableEntry for LLRP parameter TransmitPowerLevelTableEntry.
Class Definition CDISABLE_ACCESSSPEC_RESPONSE for LLRP message DISABLE_ACCESSSPEC_RESPONSE.
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
std::list< CReceiveSensitivityTableEntry * >::iterator endReceiveSensitivityTableEntry(void)
Returns the last element of the ReceiveSensitivityTableEntry sub-parameter list.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
std::list< CGPOWriteData * >::iterator endGPOWriteData(void)
Returns the last element of the GPOWriteData sub-parameter list.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
void setDurationTrigger(llrp_u32_t value)
Set accessor functions for the LLRP DurationTrigger field.
void setPeakRSSI(llrp_s8_t value)
Set accessor functions for the LLRP PeakRSSI field.
Class Definition CFirstSeenTimestampUptime for LLRP parameter FirstSeenTimestampUptime.
int countAirProtocolOpSpec(void)
Count of the LLRP AirProtocolOpSpec sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setEnablePeakRSSI(llrp_u1_t value)
Set accessor functions for the LLRP EnablePeakRSSI field.
CParameter * getTimestamp(void)
Get accessor functions for the LLRP Timestamp sub-parameter.
Class Definition CSTART_ROSPEC_RESPONSE for LLRP message START_ROSPEC_RESPONSE.
Class Definition CFieldError for LLRP parameter FieldError.
Class Definition CC1G2SingulationControl for LLRP parameter C1G2SingulationControl.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
Class Definition CAccessCommand for LLRP parameter AccessCommand.
llrp_u16_t getParameterType(void)
Get accessor functions for the LLRP ParameterType field.
EC1G2TagInventoryStateAwareS getS(void)
Get accessor functions for the LLRP S field.
Class Definition CRFTransmitter for LLRP parameter RFTransmitter.
void clearC1G2LockPayload(void)
Clears the LLRP C1G2LockPayload sub-parameter list.
void setTari(llrp_u16_t value)
Set accessor functions for the LLRP Tari field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countTagReportData(void)
Count of the LLRP TagReportData sub-parameter list.
void clearPerAntennaReceiveSensitivityRange(void)
Clears the LLRP PerAntennaReceiveSensitivityRange sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setMatch(llrp_u1_t value)
Set accessor functions for the LLRP Match field.
llrp_u1_t getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent field.
void setChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP ChannelIndex field.
Class Definition CC1G2BlockErase for LLRP parameter C1G2BlockErase.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
std::list< CAntennaProperties * >::iterator beginAntennaProperties(void)
Returns the first element of the AntennaProperties sub-parameter list.
void setDurationTriggerValue(llrp_u32_t value)
Set accessor functions for the LLRP DurationTriggerValue field.
Class Definition CENABLE_ROSPEC for LLRP message ENABLE_ROSPEC.
void setIndex(llrp_u16_t value)
Set accessor functions for the LLRP Index field.
llrp_u16_t getTari(void)
Get accessor functions for the LLRP Tari field.
llrp_u32_t getLLRPConfigurationStateValue(void)
Get accessor functions for the LLRP LLRPConfigurationStateValue field.
Class Definition CENABLE_EVENTS_AND_REPORTS for LLRP message ENABLE_EVENTS_AND_REPORTS.
llrp_u16_t getMaxNumberOfAntennaSupported(void)
Get accessor functions for the LLRP MaxNumberOfAntennaSupported field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setNumGPOs(llrp_u16_t value)
Set accessor functions for the LLRP NumGPOs field.
void clearFrequencyHopTable(void)
Clears the LLRP FrequencyHopTable sub-parameter list.
llrp_u1_t getCanSupportBlockWrite(void)
Get accessor functions for the LLRP CanSupportBlockWrite field.
EC1G2KillResultType getResult(void)
Get accessor functions for the LLRP Result field.
void setOffset(llrp_u32_t value)
Set accessor functions for the LLRP Offset field.
CParameterError * getParameterError(void)
Get accessor functions for the LLRP ParameterError sub-parameter.
Class Definition CCustom for LLRP parameter Custom.
void setEnableLastSeenTimestamp(llrp_u1_t value)
Set accessor functions for the LLRP EnableLastSeenTimestamp field.
CClientRequestResponse * getClientRequestResponse(void)
Get accessor functions for the LLRP ClientRequestResponse sub-parameter.
EAISpecEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
llrp_u16_t getNumGPOs(void)
Get accessor functions for the LLRP NumGPOs field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setNextChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP NextChannelIndex field.
llrp_u1_t getMatch(void)
Get accessor functions for the LLRP Match field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u1_t getEnableAccessSpecID(void)
Get accessor functions for the LLRP EnableAccessSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
ENotificationEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Class Definition CC1G2WriteOpSpecResult for LLRP parameter C1G2WriteOpSpecResult. ...
Class Definition CDISABLE_ROSPEC for LLRP message DISABLE_ROSPEC.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
void setKeepaliveTriggerType(EKeepaliveTriggerType value)
Set accessor functions for the LLRP KeepaliveTriggerType field.
Class Definition CRegulatoryCapabilities for LLRP parameter RegulatoryCapabilities.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CC1G2TagInventoryMask for LLRP parameter C1G2TagInventoryMask.
std::list< CParameter * >::iterator endAccessCommandOpSpecResult(void)
Returns the last element of the AccessCommandOpSpecResult sub-parameter list.
void setTagData(llrp_u1v_t value)
Set accessor functions for the LLRP TagData field.
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
std::list< CAntennaProperties * >::iterator beginAntennaProperties(void)
Returns the first element of the AntennaProperties sub-parameter list.
void setROReportTrigger(EROReportTriggerType value)
Set accessor functions for the LLRP ROReportTrigger field.
void setProtocolID(EAirProtocols value)
Set accessor functions for the LLRP ProtocolID field.
Class Definition CC1G2TagInventoryStateAwareFilterAction for LLRP parameter C1G2TagInventoryStateAwar...
CAccessSpecID * getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID sub-parameter.
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
std::list< CRFSurveyReportData * >::iterator endRFSurveyReportData(void)
Returns the last element of the RFSurveyReportData sub-parameter list.
void setMessage(llrp_utf8v_t value)
Set accessor functions for the LLRP Message field.
CParameter * getEPCParameter(void)
Get accessor functions for the LLRP EPCParameter sub-parameter.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
llrp_u16_t getCountryCode(void)
Get accessor functions for the LLRP CountryCode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
void setGPOData(llrp_u1_t value)
Set accessor functions for the LLRP GPOData field.
Class Definition CAntennaEvent for LLRP parameter AntennaEvent.
void setIDType(EIdentificationType value)
Set accessor functions for the LLRP IDType field.
Class Definition CKEEPALIVE_ACK for LLRP message KEEPALIVE_ACK.
void setCanSetAntennaProperties(llrp_u1_t value)
Set accessor functions for the LLRP CanSetAntennaProperties field.
void setParameterSubtype(llrp_u32_t value)
Set accessor functions for the LLRP ParameterSubtype field.
void setReceiverSensitivity(llrp_u16_t value)
Set accessor functions for the LLRP ReceiverSensitivity field.
void setTimeout(llrp_u32_t value)
Set accessor functions for the LLRP Timeout field.
void setNumGPIs(llrp_u16_t value)
Set accessor functions for the LLRP NumGPIs field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
void setCountryCode(llrp_u16_t value)
Set accessor functions for the LLRP CountryCode field.
Class Definition CC1G2BlockWrite for LLRP parameter C1G2BlockWrite.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
Class Definition CCLIENT_REQUEST_OP_RESPONSE for LLRP message CLIENT_REQUEST_OP_RESPONSE.
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
std::list< CFrequencyRSSILevelEntry * >::iterator beginFrequencyRSSILevelEntry(void)
Returns the first element of the FrequencyRSSILevelEntry sub-parameter list.
Class Definition CENABLE_ACCESSSPEC for LLRP message ENABLE_ACCESSSPEC.
std::list< CC1G2TargetTag * >::iterator beginC1G2TargetTag(void)
Returns the first element of the C1G2TargetTag sub-parameter list.
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
CC1G2TagInventoryStateAwareSingulationAction * getC1G2TagInventoryStateAwareSingulationAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateAwareSingulationAction sub-parameter.
Class Definition CSTOP_ROSPEC_RESPONSE for LLRP message STOP_ROSPEC_RESPONSE.
void setAISpecStopTriggerType(EAISpecStopTriggerType value)
Set accessor functions for the LLRP AISpecStopTriggerType field.
llrp_u32_t getDurationTrigger(void)
Get accessor functions for the LLRP DurationTrigger field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setAction(EC1G2StateUnawareAction value)
Set accessor functions for the LLRP Action field.
ETagObservationTriggerType getTriggerType(void)
Get accessor functions for the LLRP TriggerType field.
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
llrp_u1_t getEnableFirstSeenTimestamp(void)
Get accessor functions for the LLRP EnableFirstSeenTimestamp field.
void clearAccessCommandOpSpecResult(void)
Clears the LLRP AccessCommandOpSpecResult sub-parameter list.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
void setMaxNumberOfAntennaSupported(llrp_u16_t value)
Set accessor functions for the LLRP MaxNumberOfAntennaSupported field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countEventNotificationState(void)
Count of the LLRP EventNotificationState sub-parameter list.
void setIndex(llrp_u16_t value)
Set accessor functions for the LLRP Index field.
llrp_u96_t getEPC(void)
Get accessor functions for the LLRP EPC field.
llrp_u1_t getAntennaConnected(void)
Get accessor functions for the LLRP AntennaConnected field.
llrp_u16_t getNumCollisionSlots(void)
Get accessor functions for the LLRP NumCollisionSlots field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAccessReportTrigger(EAccessReportTriggerType value)
Set accessor functions for the LLRP AccessReportTrigger field.
void setCanReportBufferFillWarning(llrp_u1_t value)
Set accessor functions for the LLRP CanReportBufferFillWarning field.
EGetReaderConfigRequestedData getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void enrollCoreTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Core into the LTKCPP registry.
Class Definition CReceiveSensitivityTableEntry for LLRP parameter ReceiveSensitivityTableEntry.
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
void setN(llrp_u32_t value)
Set accessor functions for the LLRP N field.
Class Definition CGeneralDeviceCapabilities for LLRP parameter GeneralDeviceCapabilities.
llrp_u32_t getDurationTriggerValue(void)
Get accessor functions for the LLRP DurationTriggerValue field.
void setFrequency(llrp_u32v_t value)
Set accessor functions for the LLRP Frequency field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
CPeriodicTriggerValue * getPeriodicTriggerValue(void)
Get accessor functions for the LLRP PeriodicTriggerValue sub-parameter.
void clearPerAntennaAirProtocol(void)
Clears the LLRP PerAntennaAirProtocol sub-parameter list.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
llrp_u16_t getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex field.
llrp_u16_t getGPIPortNumber(void)
Get accessor functions for the LLRP GPIPortNumber field.
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.
void setResult(EC1G2BlockEraseResultType value)
Set accessor functions for the LLRP Result field.
llrp_u1_t getCanSetAntennaProperties(void)
Get accessor functions for the LLRP CanSetAntennaProperties field.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
llrp_utf8v_t getReaderFirmwareVersion(void)
Get accessor functions for the LLRP ReaderFirmwareVersion field.
Class Definition CC1G2UHFRFModeTableEntry for LLRP parameter C1G2UHFRFModeTableEntry.
void setS(EC1G2TagInventoryStateAwareS value)
Set accessor functions for the LLRP S field.
void setData(llrp_bytesToEnd_t value)
Set accessor functions for the LLRP Data field.
llrp_u32_t getBDRValue(void)
Get accessor functions for the LLRP BDRValue field.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
CLLRPConfigurationStateValue * getLLRPConfigurationStateValue(void)
Get accessor functions for the LLRP LLRPConfigurationStateValue sub-parameter.
std::list< CEventNotificationState * >::iterator beginEventNotificationState(void)
Returns the first element of the EventNotificationState sub-parameter list.
int countC1G2LockPayload(void)
Count of the LLRP C1G2LockPayload sub-parameter list.
void setCurrentState(EAccessSpecState value)
Set accessor functions for the LLRP CurrentState field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getOperationCountValue(void)
Get accessor functions for the LLRP OperationCountValue field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CGET_ROSPECS for LLRP message GET_ROSPECS.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
Class Definition CROReportSpec for LLRP parameter ROReportSpec.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
void setReportBufferPercentageFull(llrp_u8_t value)
Set accessor functions for the LLRP ReportBufferPercentageFull field.
CLastSeenTimestampUptime * getLastSeenTimestampUptime(void)
Get accessor functions for the LLRP LastSeenTimestampUptime sub-parameter.
CConnectionCloseEvent * getConnectionCloseEvent(void)
Get accessor functions for the LLRP ConnectionCloseEvent sub-parameter.
EStatusCode getStatusCode(void)
Get accessor functions for the LLRP StatusCode field.
std::list< CRFSurveyReportData * >::iterator beginRFSurveyReportData(void)
Returns the first element of the RFSurveyReportData sub-parameter list.
void setDurationPeriod(llrp_u32_t value)
Set accessor functions for the LLRP DurationPeriod field.
Class Definition CUTCTimestamp for LLRP parameter UTCTimestamp.
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
Class Definition CChannelIndex for LLRP parameter ChannelIndex.
void setRequestedData(EGetReaderCapabilitiesRequestedData value)
Set accessor functions for the LLRP RequestedData field.
Class Definition CC1G2TagInventoryStateUnawareFilterAction for LLRP parameter C1G2TagInventoryStateUn...
Class Definition CGET_READER_CONFIG for LLRP message GET_READER_CONFIG.
llrp_u8v_t getReaderID(void)
Get accessor functions for the LLRP ReaderID field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
Class Definition CAccessSpecStopTrigger for LLRP parameter AccessSpecStopTrigger. ...
void clearROSpec(void)
Clears the LLRP ROSpec sub-parameter list.
void setEventType(EROSpecEventType value)
Set accessor functions for the LLRP EventType field.
CFieldError * getFieldError(void)
Get accessor functions for the LLRP FieldError sub-parameter.
void setPeakRSSI(llrp_s8_t value)
Set accessor functions for the LLRP PeakRSSI field.
void setStepTariValue(llrp_u32_t value)
Set accessor functions for the LLRP StepTariValue field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
CGeneralDeviceCapabilities * getGeneralDeviceCapabilities(void)
Get accessor functions for the LLRP GeneralDeviceCapabilities sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u1_t getHoldEventsAndReportsUponReconnect(void)
Get accessor functions for the LLRP HoldEventsAndReportsUponReconnect field.
Class Definition CROSpecStartTrigger for LLRP parameter ROSpecStartTrigger.
EC1G2TruncateAction getT(void)
Get accessor functions for the LLRP T field.
CAccessCommand * getAccessCommand(void)
Get accessor functions for the LLRP AccessCommand sub-parameter.
Class Definition CFrequencyInformation for LLRP parameter FrequencyInformation.
llrp_s16_t getTransmitPowerValue(void)
Get accessor functions for the LLRP TransmitPowerValue field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
std::list< CGPIPortCurrentState * >::iterator endGPIPortCurrentState(void)
Returns the last element of the GPIPortCurrentState sub-parameter list.
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EAntennaEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
void setOperationCountValue(llrp_u16_t value)
Set accessor functions for the LLRP OperationCountValue field.
std::list< CReceiveSensitivityTableEntry * >::iterator beginReceiveSensitivityTableEntry(void)
Returns the first element of the ReceiveSensitivityTableEntry sub-parameter list. ...
CAntennaEvent * getAntennaEvent(void)
Get accessor functions for the LLRP AntennaEvent sub-parameter.
llrp_u32_t getN(void)
Get accessor functions for the LLRP N field.
Class Definition CInventoryParameterSpecID for LLRP parameter InventoryParameterSpecID.
llrp_bytesToEnd_t getData(void)
Get accessor functions for the LLRP Data field.
Class Definition CPerAntennaAirProtocol for LLRP parameter PerAntennaAirProtocol. ...
void clearGPIPortCurrentState(void)
Clears the LLRP GPIPortCurrentState sub-parameter list.
llrp_u32_t getDeviceManufacturerName(void)
Get accessor functions for the LLRP DeviceManufacturerName field.
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
Class Definition CReportBufferLevelWarningEvent for LLRP parameter ReportBufferLevelWarningEvent.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Class Definition CKeepaliveSpec for LLRP parameter KeepaliveSpec.
int countC1G2TargetTag(void)
Count of the LLRP C1G2TargetTag sub-parameter list.
Class Definition CAntennaProperties for LLRP parameter AntennaProperties.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getEnableTagSeenCount(void)
Get accessor functions for the LLRP EnableTagSeenCount field.
llrp_u32_t getBandwidth(void)
Get accessor functions for the LLRP Bandwidth field.
std::list< CParameter * >::iterator beginAirProtocolTagData(void)
Returns the first element of the AirProtocolTagData sub-parameter list.
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
void setMaxNumROSpecs(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumROSpecs field.
void clearAccessSpec(void)
Clears the LLRP AccessSpec sub-parameter list.
llrp_u32_t getMaxTariValue(void)
Get accessor functions for the LLRP MaxTariValue field.
CReportBufferLevelWarningEvent * getReportBufferLevelWarningEvent(void)
Get accessor functions for the LLRP ReportBufferLevelWarningEvent sub-parameter.
Class Definition CRO_ACCESS_REPORT for LLRP message RO_ACCESS_REPORT.
Class Definition CC1G2ReadOpSpecResult for LLRP parameter C1G2ReadOpSpecResult.
llrp_u8_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
void setWriteData(llrp_u16v_t value)
Set accessor functions for the LLRP WriteData field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EC1G2BlockWriteResultType value)
Set accessor functions for the LLRP Result field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u32_t getStepTariValue(void)
Get accessor functions for the LLRP StepTariValue field.
llrp_u16v_t getWriteData(void)
Get accessor functions for the LLRP WriteData field.
Class Definition CC1G2LockPayload for LLRP parameter C1G2LockPayload.
void setSupportsClientRequestOpSpec(llrp_u1_t value)
Set accessor functions for the LLRP SupportsClientRequestOpSpec field.
Class Definition CGPITriggerValue for LLRP parameter GPITriggerValue.
void setEnableAccessSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableAccessSpecID field.
std::list< CC1G2UHFRFModeTableEntry * >::iterator beginC1G2UHFRFModeTableEntry(void)
Returns the first element of the C1G2UHFRFModeTableEntry sub-parameter list.
EC1G2DRValue getDRValue(void)
Get accessor functions for the LLRP DRValue field.
CTagReportContentSelector * getTagReportContentSelector(void)
Get accessor functions for the LLRP TagReportContentSelector sub-parameter.
Class Definition CTagSeenCount for LLRP parameter TagSeenCount.
Class Definition CAISpec for LLRP parameter AISpec.
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
void setHopTableID(llrp_u16_t value)
Set accessor functions for the LLRP HopTableID field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
CParameter * getAirProtocolSingulationDetails(void)
Get accessor functions for the LLRP AirProtocolSingulationDetails sub-parameter.
void setReceiveSensitivityIndexMax(llrp_u16_t value)
Set accessor functions for the LLRP ReceiveSensitivityIndexMax field.
Class Definition CROSpec for LLRP parameter ROSpec.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CC1G2SingulationDetails for LLRP parameter C1G2SingulationDetails.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
std::list< CFrequencyRSSILevelEntry * >::iterator endFrequencyRSSILevelEntry(void)
Returns the last element of the FrequencyRSSILevelEntry sub-parameter list.
EAccessSpecStopTriggerType getAccessSpecStopTrigger(void)
Get accessor functions for the LLRP AccessSpecStopTrigger field.
void setChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP ChannelIndex field.
EC1G2TagInventoryStateAwareI getI(void)
Get accessor functions for the LLRP I field.
CUHFBandCapabilities * getUHFBandCapabilities(void)
Get accessor functions for the LLRP UHFBandCapabilities sub-parameter.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
void setPC_Bits(llrp_u16_t value)
Set accessor functions for the LLRP PC_Bits field.
Class Definition CC1G2RFControl for LLRP parameter C1G2RFControl.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void setTimeout(llrp_u32_t value)
Set accessor functions for the LLRP Timeout field.
int countAirProtocolTagData(void)
Count of the LLRP AirProtocolTagData sub-parameter list.
llrp_u8_t getMaxNumPriorityLevelsSupported(void)
Get accessor functions for the LLRP MaxNumPriorityLevelsSupported field.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Class Definition CInventoryParameterSpec for LLRP parameter InventoryParameterSpec.
llrp_u32_t getMaxNumROSpecs(void)
Get accessor functions for the LLRP MaxNumROSpecs field.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
CFixedFrequencyTable * getFixedFrequencyTable(void)
Get accessor functions for the LLRP FixedFrequencyTable sub-parameter.
EROSpecStartTriggerType getROSpecStartTriggerType(void)
Get accessor functions for the LLRP ROSpecStartTriggerType field.
void setTriggerType(ETagObservationTriggerType value)
Set accessor functions for the LLRP TriggerType field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearEventNotificationState(void)
Clears the LLRP EventNotificationState sub-parameter list.
void setReaderID(llrp_u8v_t value)
Set accessor functions for the LLRP ReaderID field.
Class Definition CSET_READER_CONFIG_RESPONSE for LLRP message SET_READER_CONFIG_RESPONSE.
void setEnableTagSeenCount(llrp_u1_t value)
Set accessor functions for the LLRP EnableTagSeenCount field.
std::list< CInventoryParameterSpec * >::iterator endInventoryParameterSpec(void)
Returns the last element of the InventoryParameterSpec sub-parameter list.
int countReceiveSensitivityTableEntry(void)
Count of the LLRP ReceiveSensitivityTableEntry sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
CC1G2RFControl * getC1G2RFControl(void)
Get accessor functions for the LLRP C1G2RFControl sub-parameter.
EC1G2LockDataField getDataField(void)
Get accessor functions for the LLRP DataField field.
CReaderExceptionEvent * getReaderExceptionEvent(void)
Get accessor functions for the LLRP ReaderExceptionEvent sub-parameter.
void setStopTriggerType(ERFSurveySpecStopTriggerType value)
Set accessor functions for the LLRP StopTriggerType field.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
void setMaxNumInventoryParameterSpecsPerAISpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumInventoryParameterSpecsPerAISpec field. ...
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setT(llrp_u16_t value)
Set accessor functions for the LLRP T field.
Class Definition CDISABLE_ROSPEC_RESPONSE for LLRP message DISABLE_ROSPEC_RESPONSE.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
ERFSurveyEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setResult(EC1G2WriteResultType value)
Set accessor functions for the LLRP Result field.
std::list< CC1G2TargetTag * >::iterator endC1G2TargetTag(void)
Returns the last element of the C1G2TargetTag sub-parameter list.
EAirProtocols getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
Class Definition CReaderExceptionEvent for LLRP parameter ReaderExceptionEvent.
std::list< CFrequencyHopTable * >::iterator endFrequencyHopTable(void)
Returns the last element of the FrequencyHopTable sub-parameter list.
llrp_u16_t getIndex(void)
Get accessor functions for the LLRP Index field.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
void clearAccessCommandOpSpec(void)
Clears the LLRP AccessCommandOpSpec sub-parameter list.
int countAccessSpec(void)
Count of the LLRP AccessSpec sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EC1G2LockResultType getResult(void)
Get accessor functions for the LLRP Result field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
void setInventoryParameterSpecID(llrp_u16_t value)
Set accessor functions for the LLRP InventoryParameterSpecID field.
Class Definition CC1G2KillOpSpecResult for LLRP parameter C1G2KillOpSpecResult.
void setEventType(EAntennaEventType value)
Set accessor functions for the LLRP EventType field.
CAntennaID * getAntennaID(void)
Get accessor functions for the LLRP AntennaID sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CGPOWriteData for LLRP parameter GPOWriteData.
llrp_u8v_t getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setGPIEvent(llrp_u1_t value)
Set accessor functions for the LLRP GPIEvent field.
int countAntennaProperties(void)
Count of the LLRP AntennaProperties sub-parameter list.
Class Definition CC1G2BlockEraseOpSpecResult for LLRP parameter C1G2BlockEraseOpSpecResult.
Class Definition CLLRPCapabilities for LLRP parameter LLRPCapabilities.
Class Definition CEPCData for LLRP parameter EPCData.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
CRFSurveySpecStopTrigger * getRFSurveySpecStopTrigger(void)
Get accessor functions for the LLRP RFSurveySpecStopTrigger sub-parameter.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
CEventsAndReports * getEventsAndReports(void)
Get accessor functions for the LLRP EventsAndReports sub-parameter.
Class Definition CClientRequestOpSpec for LLRP parameter ClientRequestOpSpec.
Class Definition CRFSurveySpec for LLRP parameter RFSurveySpec.
void setErrorDescription(llrp_utf8v_t value)
Set accessor functions for the LLRP ErrorDescription field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countGPOWriteData(void)
Count of the LLRP GPOWriteData sub-parameter list.
Class Definition CREADER_EVENT_NOTIFICATION for LLRP message READER_EVENT_NOTIFICATION.
Class Definition CAccessSpec for LLRP parameter AccessSpec.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
EROSpecState getCurrentState(void)
Get accessor functions for the LLRP CurrentState field.
llrp_u16_t getTagPopulation(void)
Get accessor functions for the LLRP TagPopulation field.
void setFieldNum(llrp_u16_t value)
Set accessor functions for the LLRP FieldNum field.
Class Definition CCLOSE_CONNECTION for LLRP message CLOSE_CONNECTION.
void setMaxNumAccessSpecs(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumAccessSpecs field.
EC1G2BlockEraseResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u16_t getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID field.
llrp_u1_t getCanReportBufferFillWarning(void)
Get accessor functions for the LLRP CanReportBufferFillWarning field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CDELETE_ACCESSSPEC for LLRP message DELETE_ACCESSSPEC.
void setWriteData(llrp_u16v_t value)
Set accessor functions for the LLRP WriteData field.
std::list< CTagReportData * >::iterator beginTagReportData(void)
Returns the first element of the TagReportData sub-parameter list.
std::list< CParameter * >::iterator beginAirProtocolInventoryCommandSettings(void)
Returns the first element of the AirProtocolInventoryCommandSettings sub-parameter list...
Class Definition CUHFBandCapabilities for LLRP parameter UHFBandCapabilities.
void setTagInventoryStateAware(llrp_u1_t value)
Set accessor functions for the LLRP TagInventoryStateAware field.
Class Definition CAISpecEvent for LLRP parameter AISpecEvent.
void setModelName(llrp_u32_t value)
Set accessor functions for the LLRP ModelName field.
EC1G2MValue getMValue(void)
Get accessor functions for the LLRP MValue field.
int countAccessCommandOpSpec(void)
Count of the LLRP AccessCommandOpSpec sub-parameter list.
void setHasUTCClockCapability(llrp_u1_t value)
Set accessor functions for the LLRP HasUTCClockCapability field.
std::list< CAntennaProperties * >::iterator endAntennaProperties(void)
Returns the last element of the AntennaProperties sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CReaderEventNotificationSpec * getReaderEventNotificationSpec(void)
Get accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
int countFrequencyRSSILevelEntry(void)
Count of the LLRP FrequencyRSSILevelEntry sub-parameter list.
Class Definition CFixedFrequencyTable for LLRP parameter FixedFrequencyTable.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CReportBufferOverflowErrorEvent for LLRP parameter ReportBufferOverflowErrorEvent.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CADD_ACCESSSPEC for LLRP message ADD_ACCESSSPEC.
void setVendorIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP VendorIdentifier field.
CInventoryParameterSpecID * getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
void setEnableChannelIndex(llrp_u1_t value)
Set accessor functions for the LLRP EnableChannelIndex field.
void setROSpecStartTriggerType(EROSpecStartTriggerType value)
Set accessor functions for the LLRP ROSpecStartTriggerType field.
void setModeIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP ModeIdentifier field.
void setEventType(ENotificationEventType value)
Set accessor functions for the LLRP EventType field.
void setNumberOfAttempts(llrp_u16_t value)
Set accessor functions for the LLRP NumberOfAttempts field.
Class Definition CGPIPortCurrentState for LLRP parameter GPIPortCurrentState.
llrp_u1_t getGPOData(void)
Get accessor functions for the LLRP GPOData field.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
llrp_u1v_t getEPC(void)
Get accessor functions for the LLRP EPC field.
CLastSeenTimestampUTC * getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC sub-parameter.
void setErrorCode(EStatusCode value)
Set accessor functions for the LLRP ErrorCode field.
llrp_s8_t getAverageRSSI(void)
Get accessor functions for the LLRP AverageRSSI field.
llrp_u32v_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CSET_READER_CONFIG for LLRP message SET_READER_CONFIG.
std::list< CFrequencyHopTable * >::iterator beginFrequencyHopTable(void)
Returns the first element of the FrequencyHopTable sub-parameter list.
void setStatus(EConnectionAttemptStatusType value)
Set accessor functions for the LLRP Status field.
llrp_u16_t getTagCount(void)
Get accessor functions for the LLRP TagCount field.
CChannelIndex * getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u1_t getEnableChannelIndex(void)
Get accessor functions for the LLRP EnableChannelIndex field.
llrp_u32_t getMinTariValue(void)
Get accessor functions for the LLRP MinTariValue field.
void setNumEmptySlots(llrp_u16_t value)
Set accessor functions for the LLRP NumEmptySlots field.
void setMaxTariValue(llrp_u32_t value)
Set accessor functions for the LLRP MaxTariValue field.
void setReaderFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP ReaderFirmwareVersion field.
CC1G2TagInventoryMask * getC1G2TagInventoryMask(void)
Get accessor functions for the LLRP C1G2TagInventoryMask sub-parameter.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
std::list< CPerAntennaAirProtocol * >::iterator endPerAntennaAirProtocol(void)
Returns the last element of the PerAntennaAirProtocol sub-parameter list.
Class Definition CGPIOCapabilities for LLRP parameter GPIOCapabilities.
Class Definition CGET_ROSPECS_RESPONSE for LLRP message GET_ROSPECS_RESPONSE.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
void setForwardLinkModulation(EC1G2ForwardLinkModulation value)
Set accessor functions for the LLRP ForwardLinkModulation field.
void setI(EC1G2TagInventoryStateAwareI value)
Set accessor functions for the LLRP I field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
CTagReportData * getTagReportData(void)
Get accessor functions for the LLRP TagReportData sub-parameter.
EC1G2BlockWriteResultType getResult(void)
Get accessor functions for the LLRP Result field.
Class Definition CAccessReportSpec for LLRP parameter AccessReportSpec.
std::list< CAccessSpec * >::iterator endAccessSpec(void)
Returns the last element of the AccessSpec sub-parameter list.
Class Definition CDELETE_ROSPEC_RESPONSE for LLRP message DELETE_ROSPEC_RESPONSE. ...
void setEnablePCBits(llrp_u1_t value)
Set accessor functions for the LLRP EnablePCBits field.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
llrp_u1_t getSupportsClientRequestOpSpec(void)
Get accessor functions for the LLRP SupportsClientRequestOpSpec field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setMaxNumOpSpecsPerAccessSpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumOpSpecsPerAccessSpec field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
CFrequencyInformation * getFrequencyInformation(void)
Get accessor functions for the LLRP FrequencyInformation sub-parameter.
CTagSeenCount * getTagSeenCount(void)
Get accessor functions for the LLRP TagSeenCount sub-parameter.
Class Definition CCLOSE_CONNECTION_RESPONSE for LLRP message CLOSE_CONNECTION_RESPONSE.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CDISABLE_ACCESSSPEC for LLRP message DISABLE_ACCESSSPEC.
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CROSpec * >::iterator beginROSpec(void)
Returns the first element of the ROSpec sub-parameter list.
void setLLRPConfigurationStateValue(llrp_u32_t value)
Set accessor functions for the LLRP LLRPConfigurationStateValue field.
void clearGPOWriteData(void)
Clears the LLRP GPOWriteData sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CC1G2Lock for LLRP parameter C1G2Lock.
void setTarget(EC1G2StateAwareTarget value)
Set accessor functions for the LLRP Target field.
EC1G2StateAwareTarget getTarget(void)
Get accessor functions for the LLRP Target field.
void setCanSupportBlockWrite(llrp_u1_t value)
Set accessor functions for the LLRP CanSupportBlockWrite field.
Class Definition COpSpecID for LLRP parameter OpSpecID.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setAntennaIDs(llrp_u16v_t value)
Set accessor functions for the LLRP AntennaIDs field.
int countGPIPortCurrentState(void)
Count of the LLRP GPIPortCurrentState sub-parameter list.
void setCanSupportBlockErase(llrp_u1_t value)
Set accessor functions for the LLRP CanSupportBlockErase field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
Class Definition CC1G2_PC for LLRP parameter C1G2_PC.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
void clearAirProtocolOpSpec(void)
Clears the LLRP AirProtocolOpSpec sub-parameter list.
std::list< CGPOWriteData * >::iterator beginGPOWriteData(void)
Returns the first element of the GPOWriteData sub-parameter list.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
void setT(EC1G2TruncateAction value)
Set accessor functions for the LLRP T field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginAirProtocolUHFRFModeTable(void)
Returns the first element of the AirProtocolUHFRFModeTable sub-parameter list.
llrp_s8_t getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI field.
llrp_u16_t getNumGPIs(void)
Get accessor functions for the LLRP NumGPIs field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
int countSpecParameter(void)
Count of the LLRP SpecParameter sub-parameter list.
Class Definition CENABLE_ROSPEC_RESPONSE for LLRP message ENABLE_ROSPEC_RESPONSE. ...
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getEnableROSpecID(void)
Get accessor functions for the LLRP EnableROSpecID field.
void setHoldEventsAndReportsUponReconnect(llrp_u1_t value)
Set accessor functions for the LLRP HoldEventsAndReportsUponReconnect field.
llrp_u32_t getMaxNumOpSpecsPerAccessSpec(void)
Get accessor functions for the LLRP MaxNumOpSpecsPerAccessSpec field.
void clearAirProtocolTagData(void)
Clears the LLRP AirProtocolTagData sub-parameter list.
llrp_u1_t getEnableCRC(void)
Get accessor functions for the LLRP EnableCRC field.
void setMinTariValue(llrp_u32_t value)
Set accessor functions for the LLRP MinTariValue field.
void clearGPIPortCurrentState(void)
Clears the LLRP GPIPortCurrentState sub-parameter list.
void clearAirProtocolInventoryCommandSettings(void)
Clears the LLRP AirProtocolInventoryCommandSettings sub-parameter list.
CFieldError * getFieldError(void)
Get accessor functions for the LLRP FieldError sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
ERFSurveySpecStopTriggerType getStopTriggerType(void)
Get accessor functions for the LLRP StopTriggerType field.
void setNumWordsWritten(llrp_u16_t value)
Set accessor functions for the LLRP NumWordsWritten field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CGET_READER_CAPABILITIES for LLRP message GET_READER_CAPABILITIES.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getGPOPortNumber(void)
Get accessor functions for the LLRP GPOPortNumber field.
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
llrp_u16_t getNumberOfTags(void)
Get accessor functions for the LLRP NumberOfTags field.
COpSpecID * getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID sub-parameter.
void setMessageSubtype(llrp_u8_t value)
Set accessor functions for the LLRP MessageSubtype field.
llrp_u1_t getHopping(void)
Get accessor functions for the LLRP Hopping field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
void setCommunicationsStandard(ECommunicationsStandard value)
Set accessor functions for the LLRP CommunicationsStandard field.
Class Definition CC1G2BlockWriteOpSpecResult for LLRP parameter C1G2BlockWriteOpSpecResult.
void setReceiveSensitivityIndexMin(llrp_u16_t value)
Set accessor functions for the LLRP ReceiveSensitivityIndexMin field.
void setProtocolID(llrp_u8v_t value)
Set accessor functions for the LLRP ProtocolID field.
std::list< CC1G2LockPayload * >::iterator endC1G2LockPayload(void)
Returns the last element of the C1G2LockPayload sub-parameter list.
llrp_u32_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
llrp_u16_t getT(void)
Get accessor functions for the LLRP T field.
int countC1G2UHFRFModeTableEntry(void)
Count of the LLRP C1G2UHFRFModeTableEntry sub-parameter list.
llrp_u16_t getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID field.
void setVendorIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP VendorIdentifier field.
std::list< CC1G2LockPayload * >::iterator beginC1G2LockPayload(void)
Returns the first element of the C1G2LockPayload sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endAirProtocolEPCMemorySelector(void)
Returns the last element of the AirProtocolEPCMemorySelector sub-parameter list.
llrp_u16_t getIndex(void)
Get accessor functions for the LLRP Index field.
llrp_u16_t getNumEmptySlots(void)
Get accessor functions for the LLRP NumEmptySlots field.
llrp_u32_t getEndFrequency(void)
Get accessor functions for the LLRP EndFrequency field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CEventNotificationState for LLRP parameter EventNotificationState.
void setTagPopulation(llrp_u16_t value)
Set accessor functions for the LLRP TagPopulation field.
void setProtocolID(EAirProtocols value)
Set accessor functions for the LLRP ProtocolID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setParameterType(llrp_u16_t value)
Set accessor functions for the LLRP ParameterType field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CROSpec * >::iterator endROSpec(void)
Returns the last element of the ROSpec sub-parameter list.
llrp_u16_t getReceiveSensitivityIndexMin(void)
Get accessor functions for the LLRP ReceiveSensitivityIndexMin field.
llrp_u1_t getCanDoRFSurvey(void)
Get accessor functions for the LLRP CanDoRFSurvey field.
EC1G2LockPrivilege getPrivilege(void)
Get accessor functions for the LLRP Privilege field.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
int countFrequencyHopTable(void)
Count of the LLRP FrequencyHopTable sub-parameter list.
Class Definition CC1G2LLRPCapabilities for LLRP parameter C1G2LLRPCapabilities.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u32_t getModeIdentifier(void)
Get accessor functions for the LLRP ModeIdentifier field.
Class Definition CAntennaID for LLRP parameter AntennaID.
EAISpecStopTriggerType getAISpecStopTriggerType(void)
Get accessor functions for the LLRP AISpecStopTriggerType field.
std::list< CTagReportData * >::iterator endTagReportData(void)
Returns the last element of the TagReportData sub-parameter list.
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
llrp_u32_t getMaxNumInventoryParameterSpecsPerAISpec(void)
Get accessor functions for the LLRP MaxNumInventoryParameterSpecsPerAISpec field. ...
void clearGPOWriteData(void)
Clears the LLRP GPOWriteData sub-parameter list.
CGPIEvent * getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent sub-parameter.
void setN(llrp_u16_t value)
Set accessor functions for the LLRP N field.
llrp_u32_t getPIEValue(void)
Get accessor functions for the LLRP PIEValue field.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
void setAverageRSSI(llrp_s8_t value)
Set accessor functions for the LLRP AverageRSSI field.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
llrp_u16_t getReceiverSensitivity(void)
Get accessor functions for the LLRP ReceiverSensitivity field.
Class Definition CRFSurveyEvent for LLRP parameter RFSurveyEvent.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataField(EC1G2LockDataField value)
Set accessor functions for the LLRP DataField field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Class Definition CTagReportData for LLRP parameter TagReportData.
std::list< CEventNotificationState * >::iterator endEventNotificationState(void)
Returns the last element of the EventNotificationState sub-parameter list.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void setConfig(llrp_u1_t value)
Set accessor functions for the LLRP Config field.
void clearSpecParameter(void)
Clears the LLRP SpecParameter sub-parameter list.
void setEventType(EAISpecEventType value)
Set accessor functions for the LLRP EventType field.
std::list< CParameter * >::iterator beginSpecParameter(void)
Returns the first element of the SpecParameter sub-parameter list.
void setBDRValue(llrp_u32_t value)
Set accessor functions for the LLRP BDRValue field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CParameterError * getParameterError(void)
Get accessor functions for the LLRP ParameterError sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
void setCRC(llrp_u16_t value)
Set accessor functions for the LLRP CRC field.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
llrp_u16_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
void setTagCount(llrp_u16_t value)
Set accessor functions for the LLRP TagCount field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
EAirProtocols getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
CC1G2SingulationControl * getC1G2SingulationControl(void)
Get accessor functions for the LLRP C1G2SingulationControl sub-parameter.
void setAccessSpecStopTrigger(EAccessSpecStopTriggerType value)
Set accessor functions for the LLRP AccessSpecStopTrigger field.
void clearRFSurveyReportData(void)
Clears the LLRP RFSurveyReportData sub-parameter list.
EROReportTriggerType getROReportTrigger(void)
Get accessor functions for the LLRP ROReportTrigger field.
Class Definition CEventsAndReports for LLRP parameter EventsAndReports.
CEPCData * getEPCData(void)
Get accessor functions for the LLRP EPCData sub-parameter.
void setNumCollisionSlots(llrp_u16_t value)
Set accessor functions for the LLRP NumCollisionSlots field.
EGetReaderCapabilitiesRequestedData getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void setPrivilege(EC1G2LockPrivilege value)
Set accessor functions for the LLRP Privilege field.
int countInventoryParameterSpec(void)
Count of the LLRP InventoryParameterSpec sub-parameter list.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void setState(EGPIPortState value)
Set accessor functions for the LLRP State field.
std::list< CPerAntennaReceiveSensitivityRange * >::iterator endPerAntennaReceiveSensitivityRange(void)
Returns the last element of the PerAntennaReceiveSensitivityRange sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSpectralMaskIndicator(EC1G2SpectralMaskIndicator value)
Set accessor functions for the LLRP SpectralMaskIndicator field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countGPOWriteData(void)
Count of the LLRP GPOWriteData sub-parameter list.
Class Definition CC1G2InventoryCommand for LLRP parameter C1G2InventoryCommand.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
CParameter * getAirProtocolTagSpec(void)
Get accessor functions for the LLRP AirProtocolTagSpec sub-parameter.
Class Definition CADD_ROSPEC for LLRP message ADD_ROSPEC.
llrp_u1_t getConfig(void)
Get accessor functions for the LLRP Config field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u32_t getTimeout(void)
Get accessor functions for the LLRP Timeout field.
CROSpecStopTrigger * getROSpecStopTrigger(void)
Get accessor functions for the LLRP ROSpecStopTrigger sub-parameter.
llrp_u32_t getParameterSubtype(void)
Get accessor functions for the LLRP ParameterSubtype field.
void setNotificationState(llrp_u1_t value)
Set accessor functions for the LLRP NotificationState field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
int countROSpec(void)
Count of the LLRP ROSpec sub-parameter list.
llrp_u32_t getPeriod(void)
Get accessor functions for the LLRP Period field.
int countAccessCommandOpSpecResult(void)
Count of the LLRP AccessCommandOpSpecResult sub-parameter list.
ECommunicationsStandard getCommunicationsStandard(void)
Get accessor functions for the LLRP CommunicationsStandard field.
Class Definition CSTART_ROSPEC for LLRP message START_ROSPEC.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
std::list< CPerAntennaReceiveSensitivityRange * >::iterator beginPerAntennaReceiveSensitivityRange(void)
Returns the first element of the PerAntennaReceiveSensitivityRange sub-parameter list.
std::list< CGPOWriteData * >::iterator endGPOWriteData(void)
Returns the last element of the GPOWriteData sub-parameter list.
CROSpec * getROSpec(void)
Get accessor functions for the LLRP ROSpec sub-parameter.
Class Definition CC1G2Kill for LLRP parameter C1G2Kill.
void setROSpecStopTriggerType(EROSpecStopTriggerType value)
Set accessor functions for the LLRP ROSpecStopTriggerType field.
Class Definition CAntennaConfiguration for LLRP parameter AntennaConfiguration.
Class Definition CROSpecStopTrigger for LLRP parameter ROSpecStopTrigger.
llrp_u8_t getPriority(void)
Get accessor functions for the LLRP Priority field.
llrp_u1_t getEnablePeakRSSI(void)
Get accessor functions for the LLRP EnablePeakRSSI field.
Class Definition CAccessSpecID for LLRP parameter AccessSpecID.
CHoppingEvent * getHoppingEvent(void)
Get accessor functions for the LLRP HoppingEvent sub-parameter.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
void setEventType(ERFSurveyEventType value)
Set accessor functions for the LLRP EventType field.
llrp_u8_t getReportBufferPercentageFull(void)
Get accessor functions for the LLRP ReportBufferPercentageFull field.
CAccessSpecID * getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID sub-parameter.
EROSpecStopTriggerType getROSpecStopTriggerType(void)
Get accessor functions for the LLRP ROSpecStopTriggerType field.
void setTransmitPowerValue(llrp_s16_t value)
Set accessor functions for the LLRP TransmitPowerValue field.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
CLLRPCapabilities * getLLRPCapabilities(void)
Get accessor functions for the LLRP LLRPCapabilities sub-parameter.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
void setEPC(llrp_u1v_t value)
Set accessor functions for the LLRP EPC field.
llrp_u32_t getTagTransitTime(void)
Get accessor functions for the LLRP TagTransitTime field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
int countAirProtocolEPCMemorySelector(void)
Count of the LLRP AirProtocolEPCMemorySelector sub-parameter list.
llrp_u1_t getEnableLastSeenTimestamp(void)
Get accessor functions for the LLRP EnableLastSeenTimestamp field.
void clearInventoryParameterSpec(void)
Clears the LLRP InventoryParameterSpec sub-parameter list.
CROBoundarySpec * getROBoundarySpec(void)
Get accessor functions for the LLRP ROBoundarySpec sub-parameter.
void setInventoryParameterSpecID(llrp_u16_t value)
Set accessor functions for the LLRP InventoryParameterSpecID field.
void setStartFrequency(llrp_u32_t value)
Set accessor functions for the LLRP StartFrequency field.
void clearAntennaProperties(void)
Clears the LLRP AntennaProperties sub-parameter list.
Class Definition CParameterError for LLRP parameter ParameterError.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setFrequency(llrp_u32v_t value)
Set accessor functions for the LLRP Frequency field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
CEventsAndReports * getEventsAndReports(void)
Get accessor functions for the LLRP EventsAndReports sub-parameter.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
std::list< CGPIPortCurrentState * >::iterator beginGPIPortCurrentState(void)
Returns the first element of the GPIPortCurrentState sub-parameter list.
llrp_u16_t getPC_Bits(void)
Get accessor functions for the LLRP PC_Bits field.
Class Definition CC1G2TargetTag for LLRP parameter C1G2TargetTag.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
void setAction(EC1G2StateAwareAction value)
Set accessor functions for the LLRP Action field.
void setResult(EC1G2KillResultType value)
Set accessor functions for the LLRP Result field.
void setClientRequestOpSpecTimeout(llrp_u16_t value)
Set accessor functions for the LLRP ClientRequestOpSpecTimeout field.
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
llrp_u32_t getMaxNumAccessSpecs(void)
Get accessor functions for the LLRP MaxNumAccessSpecs field.
llrp_u16_t getNextChannelIndex(void)
Get accessor functions for the LLRP NextChannelIndex field.
llrp_u1_t getSupportsEventAndReportHolding(void)
Get accessor functions for the LLRP SupportsEventAndReportHolding field.
void clearC1G2UHFRFModeTableEntry(void)
Clears the LLRP C1G2UHFRFModeTableEntry sub-parameter list.
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
Class Definition CLastSeenTimestampUTC for LLRP parameter LastSeenTimestampUTC.
llrp_u16_t getFieldNum(void)
Get accessor functions for the LLRP FieldNum field.
int countAirProtocolInventoryCommandSettings(void)
Count of the LLRP AirProtocolInventoryCommandSettings sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u1_t getEnableInventoryParameterSpecID(void)
Get accessor functions for the LLRP EnableInventoryParameterSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setCanDoRFSurvey(llrp_u1_t value)
Set accessor functions for the LLRP CanDoRFSurvey field.
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
void setMaxNumSpecsPerROSpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSpecsPerROSpec field.
CReportBufferOverflowErrorEvent * getReportBufferOverflowErrorEvent(void)
Get accessor functions for the LLRP ReportBufferOverflowErrorEvent sub-parameter. ...
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPIEvent(llrp_u1_t value)
Set accessor functions for the LLRP GPIEvent field.
Class Definition CClientRequestResponse for LLRP parameter ClientRequestResponse. ...
llrp_u1_t getResetToFactoryDefault(void)
Get accessor functions for the LLRP ResetToFactoryDefault field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CGPIPortCurrentState * >::iterator beginGPIPortCurrentState(void)
Returns the first element of the GPIPortCurrentState sub-parameter list.
CAISpecStopTrigger * getAISpecStopTrigger(void)
Get accessor functions for the LLRP AISpecStopTrigger sub-parameter.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
llrp_u32_t getKillPassword(void)
Get accessor functions for the LLRP KillPassword field.
llrp_u16_t getNumWordsWritten(void)
Get accessor functions for the LLRP NumWordsWritten field.
Class Definition CADD_ROSPEC_RESPONSE for LLRP message ADD_ROSPEC_RESPONSE.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setMaxNumPriorityLevelsSupported(llrp_u8_t value)
Set accessor functions for the LLRP MaxNumPriorityLevelsSupported field.
Class Definition CAISpecStopTrigger for LLRP parameter AISpecStopTrigger.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
void setEnableInventoryParameterSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableInventoryParameterSpecID field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Class Definition CROSpecID for LLRP parameter ROSpecID.
void setDRValue(EC1G2DRValue value)
Set accessor functions for the LLRP DRValue field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CAntennaProperties * >::iterator endAntennaProperties(void)
Returns the last element of the AntennaProperties sub-parameter list.
void setEnableAntennaID(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaID field.
CReaderEventNotificationData * getReaderEventNotificationData(void)
Get accessor functions for the LLRP ReaderEventNotificationData sub-parameter.
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
void clearAirProtocolUHFRFModeTable(void)
Clears the LLRP AirProtocolUHFRFModeTable sub-parameter list.
CInventoryParameterSpecID * getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
Class Definition CFrequencyRSSILevelEntry for LLRP parameter FrequencyRSSILevelEntry.
int countPerAntennaAirProtocol(void)
Count of the LLRP PerAntennaAirProtocol sub-parameter list.
void setGPOPortNumber(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNumber field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Class Definition CDELETE_ROSPEC for LLRP message DELETE_ROSPEC.
void setResetToFactoryDefault(llrp_u1_t value)
Set accessor functions for the LLRP ResetToFactoryDefault field.
llrp_u1_t getCanSupportBlockErase(void)
Get accessor functions for the LLRP CanSupportBlockErase field.
llrp_u1_t getNotificationState(void)
Get accessor functions for the LLRP NotificationState field.
llrp_u16_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
Class Definition CReaderEventNotificationSpec for LLRP parameter ReaderEventNotificationSpec.
void setNumberOfTags(llrp_u16_t value)
Set accessor functions for the LLRP NumberOfTags field.
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSupportsEventAndReportHolding(llrp_u1_t value)
Set accessor functions for the LLRP SupportsEventAndReportHolding field.
EC1G2StateUnawareAction getAction(void)
Get accessor functions for the LLRP Action field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getTagInventoryStateAware(void)
Get accessor functions for the LLRP TagInventoryStateAware field.
llrp_u32_t getPeriodicTriggerValue(void)
Get accessor functions for the LLRP PeriodicTriggerValue field.
Class Definition CLLRPConfigurationStateValue for LLRP parameter LLRPConfigurationStateValue.
Class Definition CCLIENT_REQUEST_OP for LLRP message CLIENT_REQUEST_OP.
std::list< CParameter * >::iterator beginAirProtocolOpSpec(void)
Returns the first element of the AirProtocolOpSpec sub-parameter list.
int countAirProtocolUHFRFModeTable(void)
Count of the LLRP AirProtocolUHFRFModeTable sub-parameter list.
llrp_u16v_t getReadData(void)
Get accessor functions for the LLRP ReadData field.
llrp_u32_t getDurationPeriod(void)
Get accessor functions for the LLRP DurationPeriod field.
Class Definition CGET_READER_CONFIG_RESPONSE for LLRP message GET_READER_CONFIG_RESPONSE.
CROSpecStartTrigger * getROSpecStartTrigger(void)
Get accessor functions for the LLRP ROSpecStartTrigger sub-parameter.
Class Definition CC1G2EPCMemorySelector for LLRP parameter C1G2EPCMemorySelector. ...
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CRegulatoryCapabilities * getRegulatoryCapabilities(void)
Get accessor functions for the LLRP RegulatoryCapabilities sub-parameter.
llrp_u16_t getReceiveSensitivityIndexMax(void)
Get accessor functions for the LLRP ReceiveSensitivityIndexMax field.
CReaderEventNotificationSpec * getReaderEventNotificationSpec(void)
Get accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
Class Definition CPeriodicTriggerValue for LLRP parameter PeriodicTriggerValue.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEnableSpecIndex(llrp_u1_t value)
Set accessor functions for the LLRP EnableSpecIndex field.
void setEPC(llrp_u96_t value)
Set accessor functions for the LLRP EPC field.
int countAntennaProperties(void)
Count of the LLRP AntennaProperties sub-parameter list.
EKeepaliveTriggerType getKeepaliveTriggerType(void)
Get accessor functions for the LLRP KeepaliveTriggerType field.
Class Definition CFrequencyHopTable for LLRP parameter FrequencyHopTable.
std::list< CParameter * >::iterator endAirProtocolUHFRFModeTable(void)
Returns the last element of the AirProtocolUHFRFModeTable sub-parameter list.
EC1G2SpectralMaskIndicator getSpectralMaskIndicator(void)
Get accessor functions for the LLRP SpectralMaskIndicator field.
void clearTransmitPowerLevelTableEntry(void)
Clears the LLRP TransmitPowerLevelTableEntry sub-parameter list.
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CGET_READER_CAPABILITIES_RESPONSE for LLRP message GET_READER_CAPABILITIES_RESPONSE...
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CRFSurveyReportData for LLRP parameter RFSurveyReportData.
std::list< CParameter * >::iterator beginAccessCommandOpSpec(void)
Returns the first element of the AccessCommandOpSpec sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
EIdentificationType getIDType(void)
Get accessor functions for the LLRP IDType field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
void clearAntennaProperties(void)
Clears the LLRP AntennaProperties sub-parameter list.
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
llrp_utf8v_t getErrorDescription(void)
Get accessor functions for the LLRP ErrorDescription field.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
CRFSurveyEvent * getRFSurveyEvent(void)
Get accessor functions for the LLRP RFSurveyEvent sub-parameter.
Class Definition CKEEPALIVE for LLRP message KEEPALIVE.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CGET_ACCESSSPECS_RESPONSE for LLRP message GET_ACCESSSPECS_RESPONSE.
CAccessSpecStopTrigger * getAccessSpecStopTrigger(void)
Get accessor functions for the LLRP AccessSpecStopTrigger sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u32_t getTimeout(void)
Get accessor functions for the LLRP Timeout field.
void setTagTransitTime(llrp_u32_t value)
Set accessor functions for the LLRP TagTransitTime field.
std::list< CPerAntennaAirProtocol * >::iterator beginPerAntennaAirProtocol(void)
Returns the first element of the PerAntennaAirProtocol sub-parameter list.
Class Definition CTagReportContentSelector for LLRP parameter TagReportContentSelector.
void setNumWordsWritten(llrp_u16_t value)
Set accessor functions for the LLRP NumWordsWritten field.
Class Definition CENABLE_ACCESSSPEC_RESPONSE for LLRP message ENABLE_ACCESSSPEC_RESPONSE.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
EC1G2StateAwareAction getAction(void)
Get accessor functions for the LLRP Action field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u16_t getGPOPortNum(void)
Get accessor functions for the LLRP GPOPortNum field.
CIdentification * getIdentification(void)
Get accessor functions for the LLRP Identification sub-parameter.
EC1G2ReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
Class Definition CSTOP_ROSPEC for LLRP message STOP_ROSPEC.
std::list< CC1G2UHFRFModeTableEntry * >::iterator endC1G2UHFRFModeTableEntry(void)
Returns the last element of the C1G2UHFRFModeTableEntry sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
std::list< CInventoryParameterSpec * >::iterator beginInventoryParameterSpec(void)
Returns the first element of the InventoryParameterSpec sub-parameter list.
void setData(llrp_bytesToEnd_t value)
Set accessor functions for the LLRP Data field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CCUSTOM_MESSAGE for LLRP message CUSTOM_MESSAGE.
llrp_u1_t getEnableSpecIndex(void)
Get accessor functions for the LLRP EnableSpecIndex field.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
llrp_u1_t getEnableAntennaID(void)
Get accessor functions for the LLRP EnableAntennaID field.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countRFSurveyReportData(void)
Count of the LLRP RFSurveyReportData sub-parameter list.
void setResult(EC1G2LockResultType value)
Set accessor functions for the LLRP Result field.
void setPreemptingROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP PreemptingROSpecID field.
llrp_u16_t getNumberOfAttempts(void)
Get accessor functions for the LLRP NumberOfAttempts field.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
std::list< CParameter * >::iterator endAirProtocolInventoryCommandSettings(void)
Returns the last element of the AirProtocolInventoryCommandSettings sub-parameter list...
EStatusCode getErrorCode(void)
Get accessor functions for the LLRP ErrorCode field.
llrp_s8_t getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI field.
std::list< CParameter * >::iterator beginAccessCommandOpSpecResult(void)
Returns the first element of the AccessCommandOpSpecResult sub-parameter list.
CParameter * getAirProtocolLLRPCapabilities(void)
Get accessor functions for the LLRP AirProtocolLLRPCapabilities sub-parameter.
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
CFirstSeenTimestampUptime * getFirstSeenTimestampUptime(void)
Get accessor functions for the LLRP FirstSeenTimestampUptime sub-parameter.
Class Definition CGPIEvent for LLRP parameter GPIEvent.
CFirstSeenTimestampUTC * getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC sub-parameter.
CC1G2TagInventoryStateAwareFilterAction * getC1G2TagInventoryStateAwareFilterAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateAwareFilterAction sub-parameter.
void setCurrentState(EROSpecState value)
Set accessor functions for the LLRP CurrentState field.
void setPeriod(llrp_u32_t value)
Set accessor functions for the LLRP Period field.
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
void setAntennaGain(llrp_s16_t value)
Set accessor functions for the LLRP AntennaGain field.
void setEnableROSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableROSpecID field.
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Class Definition CHoppingEvent for LLRP parameter HoppingEvent.
void setMValue(EC1G2MValue value)
Set accessor functions for the LLRP MValue field.
void clearAirProtocolEPCMemorySelector(void)
Clears the LLRP AirProtocolEPCMemorySelector sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CGET_ACCESSSPECS for LLRP message GET_ACCESSSPECS.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CC1G2_CRC for LLRP parameter C1G2_CRC.
CParameter * getTimestamp(void)
Get accessor functions for the LLRP Timestamp sub-parameter.
Class Definition CGET_REPORT for LLRP message GET_REPORT.
void setMaxNumSelectFiltersPerQuery(llrp_u16_t value)
Set accessor functions for the LLRP MaxNumSelectFiltersPerQuery field.
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
void clearC1G2TargetTag(void)
Clears the LLRP C1G2TargetTag sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Class Definition CRFSurveySpecStopTrigger for LLRP parameter RFSurveySpecStopTrigger.
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
void setBandwidth(llrp_u32_t value)
Set accessor functions for the LLRP Bandwidth field.
void clearFrequencyRSSILevelEntry(void)
Clears the LLRP FrequencyRSSILevelEntry sub-parameter list.
void setResult(EC1G2ReadResultType value)
Set accessor functions for the LLRP Result field.
llrp_u16_t getNumWordsWritten(void)
Get accessor functions for the LLRP NumWordsWritten field.
CGPIOCapabilities * getGPIOCapabilities(void)
Get accessor functions for the LLRP GPIOCapabilities sub-parameter.
void setPriority(llrp_u8_t value)
Set accessor functions for the LLRP Priority field.
Class Definition CC1G2LockOpSpecResult for LLRP parameter C1G2LockOpSpecResult.
EC1G2ForwardLinkModulation getForwardLinkModulation(void)
Get accessor functions for the LLRP ForwardLinkModulation field.
llrp_u32v_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
CKeepaliveSpec * getKeepaliveSpec(void)
Get accessor functions for the LLRP KeepaliveSpec sub-parameter.
llrp_u32_t getOffset(void)
Get accessor functions for the LLRP Offset field.
Class Definition CRFReceiver for LLRP parameter RFReceiver.
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
llrp_u1_t getEnablePCBits(void)
Get accessor functions for the LLRP EnablePCBits field.
void setHopTableID(llrp_u16_t value)
Set accessor functions for the LLRP HopTableID field.
llrp_u32_t getStartFrequency(void)
Get accessor functions for the LLRP StartFrequency field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CROBoundarySpec for LLRP parameter ROBoundarySpec.
llrp_u1_t getEPCHAGTCConformance(void)
Get accessor functions for the LLRP EPCHAGTCConformance field.
CKeepaliveSpec * getKeepaliveSpec(void)
Get accessor functions for the LLRP KeepaliveSpec sub-parameter.
CConnectionAttemptEvent * getConnectionAttemptEvent(void)
Get accessor functions for the LLRP ConnectionAttemptEvent sub-parameter.
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
llrp_s16_t getAntennaGain(void)
Get accessor functions for the LLRP AntennaGain field.
llrp_u16_t getClientRequestOpSpecTimeout(void)
Get accessor functions for the LLRP ClientRequestOpSpecTimeout field.
llrp_u1_t getCanDoTagInventoryStateAwareSingulation(void)
Get accessor functions for the LLRP CanDoTagInventoryStateAwareSingulation field. ...
llrp_u1v_t getTagData(void)
Get accessor functions for the LLRP TagData field.
EConnectionAttemptStatusType getStatus(void)
Get accessor functions for the LLRP Status field.
EGPIPortState getState(void)
Get accessor functions for the LLRP State field.
CUTCTimestamp * getUTCTimestamp(void)
Get accessor functions for the LLRP UTCTimestamp sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endAccessCommandOpSpec(void)
Returns the last element of the AccessCommandOpSpec sub-parameter list.
Class Definition CC1G2TagSpec for LLRP parameter C1G2TagSpec.
Class Definition CROSpecEvent for LLRP parameter ROSpecEvent.
void setAntennaConnected(llrp_u1_t value)
Set accessor functions for the LLRP AntennaConnected field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setEPCHAGTCConformance(llrp_u1_t value)
Set accessor functions for the LLRP EPCHAGTCConformance field.
Class Definition CReaderEventNotificationData for LLRP parameter ReaderEventNotificationData.