LTKCPP-- LLRP Toolkit C Plus Plus Library
|
00001 00002 /* 00003 * Generated file - DO NOT EDIT 00004 * 00005 * This is the header file for the LLRP Tool Kit (LTK) 00006 * C++ (aka cpp) implementation. It is generated into a .inc file 00007 * that is included by a platform specific .h header file. 00008 * That .h file takes care of prerequisites needed by this file. 00009 */ 00010 00011 00012 /* 00013 * Message classes - forward decls 00014 */ 00015 00016 class CCUSTOM_MESSAGE; 00017 class CGET_READER_CAPABILITIES; 00018 class CGET_READER_CAPABILITIES_RESPONSE; 00019 class CADD_ROSPEC; 00020 class CADD_ROSPEC_RESPONSE; 00021 class CDELETE_ROSPEC; 00022 class CDELETE_ROSPEC_RESPONSE; 00023 class CSTART_ROSPEC; 00024 class CSTART_ROSPEC_RESPONSE; 00025 class CSTOP_ROSPEC; 00026 class CSTOP_ROSPEC_RESPONSE; 00027 class CENABLE_ROSPEC; 00028 class CENABLE_ROSPEC_RESPONSE; 00029 class CDISABLE_ROSPEC; 00030 class CDISABLE_ROSPEC_RESPONSE; 00031 class CGET_ROSPECS; 00032 class CGET_ROSPECS_RESPONSE; 00033 class CADD_ACCESSSPEC; 00034 class CADD_ACCESSSPEC_RESPONSE; 00035 class CDELETE_ACCESSSPEC; 00036 class CDELETE_ACCESSSPEC_RESPONSE; 00037 class CENABLE_ACCESSSPEC; 00038 class CENABLE_ACCESSSPEC_RESPONSE; 00039 class CDISABLE_ACCESSSPEC; 00040 class CDISABLE_ACCESSSPEC_RESPONSE; 00041 class CGET_ACCESSSPECS; 00042 class CGET_ACCESSSPECS_RESPONSE; 00043 class CCLIENT_REQUEST_OP; 00044 class CCLIENT_REQUEST_OP_RESPONSE; 00045 class CGET_READER_CONFIG; 00046 class CGET_READER_CONFIG_RESPONSE; 00047 class CSET_READER_CONFIG; 00048 class CSET_READER_CONFIG_RESPONSE; 00049 class CCLOSE_CONNECTION; 00050 class CCLOSE_CONNECTION_RESPONSE; 00051 class CGET_REPORT; 00052 class CRO_ACCESS_REPORT; 00053 class CKEEPALIVE; 00054 class CKEEPALIVE_ACK; 00055 class CREADER_EVENT_NOTIFICATION; 00056 class CENABLE_EVENTS_AND_REPORTS; 00057 class CERROR_MESSAGE; 00058 00059 /* Custom messages */ 00060 00061 00062 /* 00063 * Parameter classes - forward decls 00064 */ 00065 00066 class CUTCTimestamp; 00067 class CUptime; 00068 class CCustom; 00069 class CGeneralDeviceCapabilities; 00070 class CReceiveSensitivityTableEntry; 00071 class CPerAntennaReceiveSensitivityRange; 00072 class CPerAntennaAirProtocol; 00073 class CGPIOCapabilities; 00074 class CLLRPCapabilities; 00075 class CRegulatoryCapabilities; 00076 class CUHFBandCapabilities; 00077 class CTransmitPowerLevelTableEntry; 00078 class CFrequencyInformation; 00079 class CFrequencyHopTable; 00080 class CFixedFrequencyTable; 00081 class CROSpec; 00082 class CROBoundarySpec; 00083 class CROSpecStartTrigger; 00084 class CPeriodicTriggerValue; 00085 class CGPITriggerValue; 00086 class CROSpecStopTrigger; 00087 class CAISpec; 00088 class CAISpecStopTrigger; 00089 class CTagObservationTrigger; 00090 class CInventoryParameterSpec; 00091 class CRFSurveySpec; 00092 class CRFSurveySpecStopTrigger; 00093 class CAccessSpec; 00094 class CAccessSpecStopTrigger; 00095 class CAccessCommand; 00096 class CClientRequestOpSpec; 00097 class CClientRequestResponse; 00098 class CLLRPConfigurationStateValue; 00099 class CIdentification; 00100 class CGPOWriteData; 00101 class CKeepaliveSpec; 00102 class CAntennaProperties; 00103 class CAntennaConfiguration; 00104 class CRFReceiver; 00105 class CRFTransmitter; 00106 class CGPIPortCurrentState; 00107 class CEventsAndReports; 00108 class CROReportSpec; 00109 class CTagReportContentSelector; 00110 class CAccessReportSpec; 00111 class CTagReportData; 00112 class CEPCData; 00113 class CEPC_96; 00114 class CROSpecID; 00115 class CSpecIndex; 00116 class CInventoryParameterSpecID; 00117 class CAntennaID; 00118 class CPeakRSSI; 00119 class CChannelIndex; 00120 class CFirstSeenTimestampUTC; 00121 class CFirstSeenTimestampUptime; 00122 class CLastSeenTimestampUTC; 00123 class CLastSeenTimestampUptime; 00124 class CTagSeenCount; 00125 class CClientRequestOpSpecResult; 00126 class CAccessSpecID; 00127 class CRFSurveyReportData; 00128 class CFrequencyRSSILevelEntry; 00129 class CReaderEventNotificationSpec; 00130 class CEventNotificationState; 00131 class CReaderEventNotificationData; 00132 class CHoppingEvent; 00133 class CGPIEvent; 00134 class CROSpecEvent; 00135 class CReportBufferLevelWarningEvent; 00136 class CReportBufferOverflowErrorEvent; 00137 class CReaderExceptionEvent; 00138 class COpSpecID; 00139 class CRFSurveyEvent; 00140 class CAISpecEvent; 00141 class CAntennaEvent; 00142 class CConnectionAttemptEvent; 00143 class CConnectionCloseEvent; 00144 class CLLRPStatus; 00145 class CFieldError; 00146 class CParameterError; 00147 class CC1G2LLRPCapabilities; 00148 class CC1G2UHFRFModeTable; 00149 class CC1G2UHFRFModeTableEntry; 00150 class CC1G2InventoryCommand; 00151 class CC1G2Filter; 00152 class CC1G2TagInventoryMask; 00153 class CC1G2TagInventoryStateAwareFilterAction; 00154 class CC1G2TagInventoryStateUnawareFilterAction; 00155 class CC1G2RFControl; 00156 class CC1G2SingulationControl; 00157 class CC1G2TagInventoryStateAwareSingulationAction; 00158 class CC1G2TagSpec; 00159 class CC1G2TargetTag; 00160 class CC1G2Read; 00161 class CC1G2Write; 00162 class CC1G2Kill; 00163 class CC1G2Lock; 00164 class CC1G2LockPayload; 00165 class CC1G2BlockErase; 00166 class CC1G2BlockWrite; 00167 class CC1G2EPCMemorySelector; 00168 class CC1G2_PC; 00169 class CC1G2_CRC; 00170 class CC1G2SingulationDetails; 00171 class CC1G2ReadOpSpecResult; 00172 class CC1G2WriteOpSpecResult; 00173 class CC1G2KillOpSpecResult; 00174 class CC1G2LockOpSpecResult; 00175 class CC1G2BlockEraseOpSpecResult; 00176 class CC1G2BlockWriteOpSpecResult; 00177 00178 /* Custom parameters */ 00179 00180 00181 /* 00182 * Vendor descriptor declarations. 00183 */ 00184 00185 00186 /* 00187 * Namespace descriptor declarations. 00188 */ 00189 00190 extern const CNamespaceDescriptor 00191 g_nsdescllrp; 00192 00193 00194 /* 00195 * Enumeration definitions and declarations of 00196 * enumeration string tables. 00197 */ 00198 00199 00227 enum EAirProtocols 00228 { 00229 00230 AirProtocols_Unspecified = 0, 00231 AirProtocols_EPCGlobalClass1Gen2 = 1, 00232 }; 00233 00234 extern const SEnumTableEntry 00235 g_estAirProtocols[]; 00236 00237 00261 enum EGetReaderCapabilitiesRequestedData 00262 { 00263 00264 GetReaderCapabilitiesRequestedData_All = 0, 00265 GetReaderCapabilitiesRequestedData_General_Device_Capabilities = 1, 00266 GetReaderCapabilitiesRequestedData_LLRP_Capabilities = 2, 00267 GetReaderCapabilitiesRequestedData_Regulatory_Capabilities = 3, 00268 GetReaderCapabilitiesRequestedData_LLRP_Air_Protocol_Capabilities = 4, 00269 }; 00270 00271 extern const SEnumTableEntry 00272 g_estGetReaderCapabilitiesRequestedData[]; 00273 00274 00310 enum ECommunicationsStandard 00311 { 00312 00313 CommunicationsStandard_Unspecified = 0, 00314 CommunicationsStandard_US_FCC_Part_15 = 1, 00315 CommunicationsStandard_ETSI_302_208 = 2, 00316 CommunicationsStandard_ETSI_300_220 = 3, 00317 CommunicationsStandard_Australia_LIPD_1W = 4, 00318 CommunicationsStandard_Australia_LIPD_4W = 5, 00319 CommunicationsStandard_Japan_ARIB_STD_T89 = 6, 00320 CommunicationsStandard_Hong_Kong_OFTA_1049 = 7, 00321 CommunicationsStandard_Taiwan_DGT_LP0002 = 8, 00322 CommunicationsStandard_Korea_MIC_Article_5_2 = 9, 00323 }; 00324 00325 extern const SEnumTableEntry 00326 g_estCommunicationsStandard[]; 00327 00328 00350 enum EROSpecState 00351 { 00352 00353 ROSpecState_Disabled = 0, 00354 ROSpecState_Inactive = 1, 00355 ROSpecState_Active = 2, 00356 }; 00357 00358 extern const SEnumTableEntry 00359 g_estROSpecState[]; 00360 00361 00415 enum EROSpecStartTriggerType 00416 { 00417 00418 ROSpecStartTriggerType_Null = 0, 00419 ROSpecStartTriggerType_Immediate = 1, 00420 ROSpecStartTriggerType_Periodic = 2, 00421 ROSpecStartTriggerType_GPI = 3, 00422 }; 00423 00424 extern const SEnumTableEntry 00425 g_estROSpecStartTriggerType[]; 00426 00427 00475 enum EROSpecStopTriggerType 00476 { 00477 00478 ROSpecStopTriggerType_Null = 0, 00479 ROSpecStopTriggerType_Duration = 1, 00480 ROSpecStopTriggerType_GPI_With_Timeout = 2, 00481 }; 00482 00483 extern const SEnumTableEntry 00484 g_estROSpecStopTriggerType[]; 00485 00486 00540 enum EAISpecStopTriggerType 00541 { 00542 00543 AISpecStopTriggerType_Null = 0, 00544 AISpecStopTriggerType_Duration = 1, 00545 AISpecStopTriggerType_GPI_With_Timeout = 2, 00546 AISpecStopTriggerType_Tag_Observation = 3, 00547 }; 00548 00549 extern const SEnumTableEntry 00550 g_estAISpecStopTriggerType[]; 00551 00552 00600 enum ETagObservationTriggerType 00601 { 00602 00603 TagObservationTriggerType_Upon_Seeing_N_Tags_Or_Timeout = 0, 00604 TagObservationTriggerType_Upon_Seeing_No_More_New_Tags_For_Tms_Or_Timeout = 1, 00605 TagObservationTriggerType_N_Attempts_To_See_All_Tags_In_FOV_Or_Timeout = 2, 00606 }; 00607 00608 extern const SEnumTableEntry 00609 g_estTagObservationTriggerType[]; 00610 00611 00633 enum ERFSurveySpecStopTriggerType 00634 { 00635 00636 RFSurveySpecStopTriggerType_Null = 0, 00637 RFSurveySpecStopTriggerType_Duration = 1, 00638 RFSurveySpecStopTriggerType_N_Iterations_Through_Frequency_Range = 2, 00639 }; 00640 00641 extern const SEnumTableEntry 00642 g_estRFSurveySpecStopTriggerType[]; 00643 00644 00665 enum EAccessSpecState 00666 { 00667 00668 AccessSpecState_Disabled = 0, 00669 AccessSpecState_Active = 1, 00670 }; 00671 00672 extern const SEnumTableEntry 00673 g_estAccessSpecState[]; 00674 00675 00717 enum EAccessSpecStopTriggerType 00718 { 00719 00720 AccessSpecStopTriggerType_Null = 0, 00721 AccessSpecStopTriggerType_Operation_Count = 1, 00722 }; 00723 00724 extern const SEnumTableEntry 00725 g_estAccessSpecStopTriggerType[]; 00726 00727 00758 enum EGetReaderConfigRequestedData 00759 { 00760 00761 GetReaderConfigRequestedData_All = 0, 00762 GetReaderConfigRequestedData_Identification = 1, 00763 GetReaderConfigRequestedData_AntennaProperties = 2, 00764 GetReaderConfigRequestedData_AntennaConfiguration = 3, 00765 GetReaderConfigRequestedData_ROReportSpec = 4, 00766 GetReaderConfigRequestedData_ReaderEventNotificationSpec = 5, 00767 GetReaderConfigRequestedData_AccessReportSpec = 6, 00768 GetReaderConfigRequestedData_LLRPConfigurationStateValue = 7, 00769 GetReaderConfigRequestedData_KeepaliveSpec = 8, 00770 GetReaderConfigRequestedData_GPIPortCurrentState = 9, 00771 GetReaderConfigRequestedData_GPOWriteData = 10, 00772 GetReaderConfigRequestedData_EventsAndReports = 11, 00773 }; 00774 00775 extern const SEnumTableEntry 00776 g_estGetReaderConfigRequestedData[]; 00777 00778 00799 enum EIdentificationType 00800 { 00801 00802 IdentificationType_MAC_Address = 0, 00803 IdentificationType_EPC = 1, 00804 }; 00805 00806 extern const SEnumTableEntry 00807 g_estIdentificationType[]; 00808 00809 00853 enum EKeepaliveTriggerType 00854 { 00855 00856 KeepaliveTriggerType_Null = 0, 00857 KeepaliveTriggerType_Periodic = 1, 00858 }; 00859 00860 extern const SEnumTableEntry 00861 g_estKeepaliveTriggerType[]; 00862 00863 00885 enum EGPIPortState 00886 { 00887 00888 GPIPortState_Low = 0, 00889 GPIPortState_High = 1, 00890 GPIPortState_Unknown = 2, 00891 }; 00892 00893 extern const SEnumTableEntry 00894 g_estGPIPortState[]; 00895 00896 00918 enum EROReportTriggerType 00919 { 00920 00921 ROReportTriggerType_None = 0, 00922 ROReportTriggerType_Upon_N_Tags_Or_End_Of_AISpec = 1, 00923 ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec = 2, 00924 }; 00925 00926 extern const SEnumTableEntry 00927 g_estROReportTriggerType[]; 00928 00929 00950 enum EAccessReportTriggerType 00951 { 00952 00953 AccessReportTriggerType_Whenever_ROReport_Is_Generated = 0, 00954 AccessReportTriggerType_End_Of_AccessSpec = 1, 00955 }; 00956 00957 extern const SEnumTableEntry 00958 g_estAccessReportTriggerType[]; 00959 00960 00988 enum ENotificationEventType 00989 { 00990 00991 NotificationEventType_Upon_Hopping_To_Next_Channel = 0, 00992 NotificationEventType_GPI_Event = 1, 00993 NotificationEventType_ROSpec_Event = 2, 00994 NotificationEventType_Report_Buffer_Fill_Warning = 3, 00995 NotificationEventType_Reader_Exception_Event = 4, 00996 NotificationEventType_RFSurvey_Event = 5, 00997 NotificationEventType_AISpec_Event = 6, 00998 NotificationEventType_AISpec_Event_With_Details = 7, 00999 NotificationEventType_Antenna_Event = 8, 01000 }; 01001 01002 extern const SEnumTableEntry 01003 g_estNotificationEventType[]; 01004 01005 01027 enum EROSpecEventType 01028 { 01029 01030 ROSpecEventType_Start_Of_ROSpec = 0, 01031 ROSpecEventType_End_Of_ROSpec = 1, 01032 ROSpecEventType_Preemption_Of_ROSpec = 2, 01033 }; 01034 01035 extern const SEnumTableEntry 01036 g_estROSpecEventType[]; 01037 01038 01059 enum ERFSurveyEventType 01060 { 01061 01062 RFSurveyEventType_Start_Of_RFSurvey = 0, 01063 RFSurveyEventType_End_Of_RFSurvey = 1, 01064 }; 01065 01066 extern const SEnumTableEntry 01067 g_estRFSurveyEventType[]; 01068 01069 01089 enum EAISpecEventType 01090 { 01091 01092 AISpecEventType_End_Of_AISpec = 0, 01093 }; 01094 01095 extern const SEnumTableEntry 01096 g_estAISpecEventType[]; 01097 01098 01120 enum EAntennaEventType 01121 { 01122 01123 AntennaEventType_Antenna_Disconnected = 0, 01124 AntennaEventType_Antenna_Connected = 1, 01125 }; 01126 01127 extern const SEnumTableEntry 01128 g_estAntennaEventType[]; 01129 01130 01158 enum EConnectionAttemptStatusType 01159 { 01160 01161 ConnectionAttemptStatusType_Success = 0, 01162 ConnectionAttemptStatusType_Failed_A_Reader_Initiated_Connection_Already_Exists = 1, 01163 ConnectionAttemptStatusType_Failed_A_Client_Initiated_Connection_Already_Exists = 2, 01164 ConnectionAttemptStatusType_Failed_Reason_Other_Than_A_Connection_Already_Exists = 3, 01165 ConnectionAttemptStatusType_Another_Connection_Attempted = 4, 01166 }; 01167 01168 extern const SEnumTableEntry 01169 g_estConnectionAttemptStatusType[]; 01170 01171 01223 enum EStatusCode 01224 { 01225 01226 StatusCode_M_Success = 0, 01227 StatusCode_M_ParameterError = 100, 01228 StatusCode_M_FieldError = 101, 01229 StatusCode_M_UnexpectedParameter = 102, 01230 StatusCode_M_MissingParameter = 103, 01231 StatusCode_M_DuplicateParameter = 104, 01232 StatusCode_M_OverflowParameter = 105, 01233 StatusCode_M_OverflowField = 106, 01234 StatusCode_M_UnknownParameter = 107, 01235 StatusCode_M_UnknownField = 108, 01236 StatusCode_M_UnsupportedMessage = 109, 01237 StatusCode_M_UnsupportedVersion = 110, 01238 StatusCode_M_UnsupportedParameter = 111, 01239 StatusCode_P_ParameterError = 200, 01240 StatusCode_P_FieldError = 201, 01241 StatusCode_P_UnexpectedParameter = 202, 01242 StatusCode_P_MissingParameter = 203, 01243 StatusCode_P_DuplicateParameter = 204, 01244 StatusCode_P_OverflowParameter = 205, 01245 StatusCode_P_OverflowField = 206, 01246 StatusCode_P_UnknownParameter = 207, 01247 StatusCode_P_UnknownField = 208, 01248 StatusCode_P_UnsupportedParameter = 209, 01249 StatusCode_A_Invalid = 300, 01250 StatusCode_A_OutOfRange = 301, 01251 StatusCode_R_DeviceError = 401, 01252 }; 01253 01254 extern const SEnumTableEntry 01255 g_estStatusCode[]; 01256 01257 01278 enum EC1G2DRValue 01279 { 01280 01281 C1G2DRValue_DRV_8 = 0, 01282 C1G2DRValue_DRV_64_3 = 1, 01283 }; 01284 01285 extern const SEnumTableEntry 01286 g_estC1G2DRValue[]; 01287 01288 01311 enum EC1G2MValue 01312 { 01313 01314 C1G2MValue_MV_FM0 = 0, 01315 C1G2MValue_MV_2 = 1, 01316 C1G2MValue_MV_4 = 2, 01317 C1G2MValue_MV_8 = 3, 01318 }; 01319 01320 extern const SEnumTableEntry 01321 g_estC1G2MValue[]; 01322 01323 01345 enum EC1G2ForwardLinkModulation 01346 { 01347 01348 C1G2ForwardLinkModulation_PR_ASK = 0, 01349 C1G2ForwardLinkModulation_SSB_ASK = 1, 01350 C1G2ForwardLinkModulation_DSB_ASK = 2, 01351 }; 01352 01353 extern const SEnumTableEntry 01354 g_estC1G2ForwardLinkModulation[]; 01355 01356 01410 enum EC1G2SpectralMaskIndicator 01411 { 01412 01413 C1G2SpectralMaskIndicator_Unknown = 0, 01414 C1G2SpectralMaskIndicator_SI = 1, 01415 C1G2SpectralMaskIndicator_MI = 2, 01416 C1G2SpectralMaskIndicator_DI = 3, 01417 }; 01418 01419 extern const SEnumTableEntry 01420 g_estC1G2SpectralMaskIndicator[]; 01421 01422 01444 enum EC1G2TruncateAction 01445 { 01446 01447 C1G2TruncateAction_Unspecified = 0, 01448 C1G2TruncateAction_Do_Not_Truncate = 1, 01449 C1G2TruncateAction_Truncate = 2, 01450 }; 01451 01452 extern const SEnumTableEntry 01453 g_estC1G2TruncateAction[]; 01454 01455 01479 enum EC1G2StateAwareTarget 01480 { 01481 01482 C1G2StateAwareTarget_SL = 0, 01483 C1G2StateAwareTarget_Inventoried_State_For_Session_S0 = 1, 01484 C1G2StateAwareTarget_Inventoried_State_For_Session_S1 = 2, 01485 C1G2StateAwareTarget_Inventoried_State_For_Session_S2 = 3, 01486 C1G2StateAwareTarget_Inventoried_State_For_Session_S3 = 4, 01487 }; 01488 01489 extern const SEnumTableEntry 01490 g_estC1G2StateAwareTarget[]; 01491 01492 01519 enum EC1G2StateAwareAction 01520 { 01521 01522 C1G2StateAwareAction_AssertSLOrA_DeassertSLOrB = 0, 01523 C1G2StateAwareAction_AssertSLOrA_Noop = 1, 01524 C1G2StateAwareAction_Noop_DeassertSLOrB = 2, 01525 C1G2StateAwareAction_NegateSLOrABBA_Noop = 3, 01526 C1G2StateAwareAction_DeassertSLOrB_AssertSLOrA = 4, 01527 C1G2StateAwareAction_DeassertSLOrB_Noop = 5, 01528 C1G2StateAwareAction_Noop_AssertSLOrA = 6, 01529 C1G2StateAwareAction_Noop_NegateSLOrABBA = 7, 01530 }; 01531 01532 extern const SEnumTableEntry 01533 g_estC1G2StateAwareAction[]; 01534 01535 01560 enum EC1G2StateUnawareAction 01561 { 01562 01563 C1G2StateUnawareAction_Select_Unselect = 0, 01564 C1G2StateUnawareAction_Select_DoNothing = 1, 01565 C1G2StateUnawareAction_DoNothing_Unselect = 2, 01566 C1G2StateUnawareAction_Unselect_DoNothing = 3, 01567 C1G2StateUnawareAction_Unselect_Select = 4, 01568 C1G2StateUnawareAction_DoNothing_Select = 5, 01569 }; 01570 01571 extern const SEnumTableEntry 01572 g_estC1G2StateUnawareAction[]; 01573 01574 01595 enum EC1G2TagInventoryStateAwareI 01596 { 01597 01598 C1G2TagInventoryStateAwareI_State_A = 0, 01599 C1G2TagInventoryStateAwareI_State_B = 1, 01600 }; 01601 01602 extern const SEnumTableEntry 01603 g_estC1G2TagInventoryStateAwareI[]; 01604 01605 01626 enum EC1G2TagInventoryStateAwareS 01627 { 01628 01629 C1G2TagInventoryStateAwareS_SL = 0, 01630 C1G2TagInventoryStateAwareS_Not_SL = 1, 01631 }; 01632 01633 extern const SEnumTableEntry 01634 g_estC1G2TagInventoryStateAwareS[]; 01635 01636 01666 enum EC1G2LockPrivilege 01667 { 01668 01669 C1G2LockPrivilege_Read_Write = 0, 01670 C1G2LockPrivilege_Perma_Lock = 1, 01671 C1G2LockPrivilege_Perma_Unlock = 2, 01672 C1G2LockPrivilege_Unlock = 3, 01673 }; 01674 01675 extern const SEnumTableEntry 01676 g_estC1G2LockPrivilege[]; 01677 01678 01702 enum EC1G2LockDataField 01703 { 01704 01705 C1G2LockDataField_Kill_Password = 0, 01706 C1G2LockDataField_Access_Password = 1, 01707 C1G2LockDataField_EPC_Memory = 2, 01708 C1G2LockDataField_TID_Memory = 3, 01709 C1G2LockDataField_User_Memory = 4, 01710 }; 01711 01712 extern const SEnumTableEntry 01713 g_estC1G2LockDataField[]; 01714 01715 01738 enum EC1G2ReadResultType 01739 { 01740 01741 C1G2ReadResultType_Success = 0, 01742 C1G2ReadResultType_Nonspecific_Tag_Error = 1, 01743 C1G2ReadResultType_No_Response_From_Tag = 2, 01744 C1G2ReadResultType_Nonspecific_Reader_Error = 3, 01745 }; 01746 01747 extern const SEnumTableEntry 01748 g_estC1G2ReadResultType[]; 01749 01750 01780 enum EC1G2WriteResultType 01781 { 01782 01783 C1G2WriteResultType_Success = 0, 01784 C1G2WriteResultType_Tag_Memory_Overrun_Error = 1, 01785 C1G2WriteResultType_Tag_Memory_Locked_Error = 2, 01786 C1G2WriteResultType_Insufficient_Power = 3, 01787 C1G2WriteResultType_Nonspecific_Tag_Error = 4, 01788 C1G2WriteResultType_No_Response_From_Tag = 5, 01789 C1G2WriteResultType_Nonspecific_Reader_Error = 6, 01790 }; 01791 01792 extern const SEnumTableEntry 01793 g_estC1G2WriteResultType[]; 01794 01795 01820 enum EC1G2KillResultType 01821 { 01822 01823 C1G2KillResultType_Success = 0, 01824 C1G2KillResultType_Zero_Kill_Password_Error = 1, 01825 C1G2KillResultType_Insufficient_Power = 2, 01826 C1G2KillResultType_Nonspecific_Tag_Error = 3, 01827 C1G2KillResultType_No_Response_From_Tag = 4, 01828 C1G2KillResultType_Nonspecific_Reader_Error = 5, 01829 }; 01830 01831 extern const SEnumTableEntry 01832 g_estC1G2KillResultType[]; 01833 01834 01858 enum EC1G2LockResultType 01859 { 01860 01861 C1G2LockResultType_Success = 0, 01862 C1G2LockResultType_Insufficient_Power = 1, 01863 C1G2LockResultType_Nonspecific_Tag_Error = 2, 01864 C1G2LockResultType_No_Response_From_Tag = 3, 01865 C1G2LockResultType_Nonspecific_Reader_Error = 4, 01866 }; 01867 01868 extern const SEnumTableEntry 01869 g_estC1G2LockResultType[]; 01870 01871 01897 enum EC1G2BlockEraseResultType 01898 { 01899 01900 C1G2BlockEraseResultType_Success = 0, 01901 C1G2BlockEraseResultType_Tag_Memory_Overrun_Error = 1, 01902 C1G2BlockEraseResultType_Tag_Memory_Locked_Error = 2, 01903 C1G2BlockEraseResultType_Insufficient_Power = 3, 01904 C1G2BlockEraseResultType_Nonspecific_Tag_Error = 4, 01905 C1G2BlockEraseResultType_No_Response_From_Tag = 5, 01906 C1G2BlockEraseResultType_Nonspecific_Reader_Error = 6, 01907 }; 01908 01909 extern const SEnumTableEntry 01910 g_estC1G2BlockEraseResultType[]; 01911 01912 01942 enum EC1G2BlockWriteResultType 01943 { 01944 01945 C1G2BlockWriteResultType_Success = 0, 01946 C1G2BlockWriteResultType_Tag_Memory_Overrun_Error = 1, 01947 C1G2BlockWriteResultType_Tag_Memory_Locked_Error = 2, 01948 C1G2BlockWriteResultType_Insufficient_Power = 3, 01949 C1G2BlockWriteResultType_Nonspecific_Tag_Error = 4, 01950 C1G2BlockWriteResultType_No_Response_From_Tag = 5, 01951 C1G2BlockWriteResultType_Nonspecific_Reader_Error = 6, 01952 }; 01953 01954 extern const SEnumTableEntry 01955 g_estC1G2BlockWriteResultType[]; 01956 01957 01963 02003 class CCUSTOM_MESSAGE : public CMessage 02004 { 02005 public: 02006 CCUSTOM_MESSAGE (void); 02007 ~CCUSTOM_MESSAGE (void); 02008 02011 02012 static const CFieldDescriptor * const 02013 s_apFieldDescriptorTable[]; 02014 02015 static const CTypeDescriptor 02016 s_typeDescriptor; 02017 02018 void 02019 decodeFields ( 02020 CDecoderStream * pDecoderStream); 02021 02022 void 02023 assimilateSubParameters ( 02024 CErrorDetails * pError); 02025 02026 void 02027 encode ( 02028 CEncoderStream * pEncoderStream) const; 02029 02030 02031 02032 static CElement * 02033 s_construct (void); 02034 02035 static void 02036 s_decodeFields ( 02037 CDecoderStream * pDecoderStream, 02038 CElement * pElement); 02040 02041 02042 protected: 02043 llrp_u32_t m_VendorIdentifier; 02044 02047 public: 02048 static const CFieldDescriptor 02049 s_fdVendorIdentifier; 02051 02053 inline llrp_u32_t 02054 getVendorIdentifier (void) 02055 { 02056 return m_VendorIdentifier; 02057 } 02058 02060 inline void 02061 setVendorIdentifier ( 02062 llrp_u32_t value) 02063 { 02064 m_VendorIdentifier = value; 02065 } 02066 02067 02068 protected: 02069 llrp_u8_t m_MessageSubtype; 02070 02073 public: 02074 static const CFieldDescriptor 02075 s_fdMessageSubtype; 02077 02079 inline llrp_u8_t 02080 getMessageSubtype (void) 02081 { 02082 return m_MessageSubtype; 02083 } 02084 02086 inline void 02087 setMessageSubtype ( 02088 llrp_u8_t value) 02089 { 02090 m_MessageSubtype = value; 02091 } 02092 02093 02094 protected: 02095 llrp_bytesToEnd_t m_Data; 02096 02099 public: 02100 static const CFieldDescriptor 02101 s_fdData; 02103 02105 inline llrp_bytesToEnd_t 02106 getData (void) 02107 { 02108 return m_Data; 02109 } 02110 02112 inline void 02113 setData ( 02114 llrp_bytesToEnd_t value) 02115 { 02116 m_Data = value; 02117 } 02118 02119 02120 02121 }; 02122 02123 02155 class CGET_READER_CAPABILITIES : public CMessage 02156 { 02157 public: 02158 CGET_READER_CAPABILITIES (void); 02159 ~CGET_READER_CAPABILITIES (void); 02160 02163 02164 static const CFieldDescriptor * const 02165 s_apFieldDescriptorTable[]; 02166 02167 static const CTypeDescriptor 02168 s_typeDescriptor; 02169 02170 void 02171 decodeFields ( 02172 CDecoderStream * pDecoderStream); 02173 02174 void 02175 assimilateSubParameters ( 02176 CErrorDetails * pError); 02177 02178 void 02179 encode ( 02180 CEncoderStream * pEncoderStream) const; 02181 02182 02183 02184 static CElement * 02185 s_construct (void); 02186 02187 static void 02188 s_decodeFields ( 02189 CDecoderStream * pDecoderStream, 02190 CElement * pElement); 02192 02193 02194 protected: 02195 EGetReaderCapabilitiesRequestedData m_eRequestedData; 02196 02199 public: 02200 static const CFieldDescriptor 02201 s_fdRequestedData; 02203 02205 inline EGetReaderCapabilitiesRequestedData 02206 getRequestedData (void) 02207 { 02208 return m_eRequestedData; 02209 } 02210 02212 inline void 02213 setRequestedData ( 02214 EGetReaderCapabilitiesRequestedData value) 02215 { 02216 m_eRequestedData = value; 02217 } 02218 02219 02220 02221 protected: 02222 std::list<CParameter *> m_listCustom; 02223 02224 public: 02226 inline std::list<CParameter *>::iterator 02227 beginCustom (void) 02228 { 02229 return m_listCustom.begin(); 02230 } 02231 02233 inline std::list<CParameter *>::iterator 02234 endCustom (void) 02235 { 02236 return m_listCustom.end(); 02237 } 02238 02240 inline void 02241 clearCustom (void) 02242 { 02243 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02244 } 02245 02247 inline int 02248 countCustom (void) 02249 { 02250 return (int) (m_listCustom.size()); 02251 } 02252 02253 EResultCode 02255 addCustom ( 02256 CParameter * pValue); 02257 02258 02259 }; 02260 02261 02297 class CGET_READER_CAPABILITIES_RESPONSE : public CMessage 02298 { 02299 public: 02300 CGET_READER_CAPABILITIES_RESPONSE (void); 02301 ~CGET_READER_CAPABILITIES_RESPONSE (void); 02302 02305 02306 static const CFieldDescriptor * const 02307 s_apFieldDescriptorTable[]; 02308 02309 static const CTypeDescriptor 02310 s_typeDescriptor; 02311 02312 void 02313 decodeFields ( 02314 CDecoderStream * pDecoderStream); 02315 02316 void 02317 assimilateSubParameters ( 02318 CErrorDetails * pError); 02319 02320 void 02321 encode ( 02322 CEncoderStream * pEncoderStream) const; 02323 02324 02325 02326 static CElement * 02327 s_construct (void); 02328 02329 static void 02330 s_decodeFields ( 02331 CDecoderStream * pDecoderStream, 02332 CElement * pElement); 02334 02335 02336 02337 protected: 02338 CLLRPStatus * m_pLLRPStatus; 02339 02340 public: 02342 inline CLLRPStatus * 02343 getLLRPStatus (void) 02344 { 02345 return m_pLLRPStatus; 02346 } 02347 02349 EResultCode 02350 setLLRPStatus ( 02351 CLLRPStatus * pValue); 02352 02353 02354 protected: 02355 CGeneralDeviceCapabilities * m_pGeneralDeviceCapabilities; 02356 02357 public: 02359 inline CGeneralDeviceCapabilities * 02360 getGeneralDeviceCapabilities (void) 02361 { 02362 return m_pGeneralDeviceCapabilities; 02363 } 02364 02366 EResultCode 02367 setGeneralDeviceCapabilities ( 02368 CGeneralDeviceCapabilities * pValue); 02369 02370 02371 protected: 02372 CLLRPCapabilities * m_pLLRPCapabilities; 02373 02374 public: 02376 inline CLLRPCapabilities * 02377 getLLRPCapabilities (void) 02378 { 02379 return m_pLLRPCapabilities; 02380 } 02381 02383 EResultCode 02384 setLLRPCapabilities ( 02385 CLLRPCapabilities * pValue); 02386 02387 02388 protected: 02389 CRegulatoryCapabilities * m_pRegulatoryCapabilities; 02390 02391 public: 02393 inline CRegulatoryCapabilities * 02394 getRegulatoryCapabilities (void) 02395 { 02396 return m_pRegulatoryCapabilities; 02397 } 02398 02400 EResultCode 02401 setRegulatoryCapabilities ( 02402 CRegulatoryCapabilities * pValue); 02403 02404 02405 protected: 02406 CParameter * m_pAirProtocolLLRPCapabilities; 02407 02408 public: 02410 inline CParameter * 02411 getAirProtocolLLRPCapabilities (void) 02412 { 02413 return m_pAirProtocolLLRPCapabilities; 02414 } 02415 02417 EResultCode 02418 setAirProtocolLLRPCapabilities ( 02419 CParameter * pValue); 02420 02421 02422 protected: 02423 std::list<CParameter *> m_listCustom; 02424 02425 public: 02427 inline std::list<CParameter *>::iterator 02428 beginCustom (void) 02429 { 02430 return m_listCustom.begin(); 02431 } 02432 02434 inline std::list<CParameter *>::iterator 02435 endCustom (void) 02436 { 02437 return m_listCustom.end(); 02438 } 02439 02441 inline void 02442 clearCustom (void) 02443 { 02444 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02445 } 02446 02448 inline int 02449 countCustom (void) 02450 { 02451 return (int) (m_listCustom.size()); 02452 } 02453 02454 EResultCode 02456 addCustom ( 02457 CParameter * pValue); 02458 02459 02460 }; 02461 02462 02502 class CADD_ROSPEC : public CMessage 02503 { 02504 public: 02505 CADD_ROSPEC (void); 02506 ~CADD_ROSPEC (void); 02507 02510 02511 static const CFieldDescriptor * const 02512 s_apFieldDescriptorTable[]; 02513 02514 static const CTypeDescriptor 02515 s_typeDescriptor; 02516 02517 void 02518 decodeFields ( 02519 CDecoderStream * pDecoderStream); 02520 02521 void 02522 assimilateSubParameters ( 02523 CErrorDetails * pError); 02524 02525 void 02526 encode ( 02527 CEncoderStream * pEncoderStream) const; 02528 02529 02530 02531 static CElement * 02532 s_construct (void); 02533 02534 static void 02535 s_decodeFields ( 02536 CDecoderStream * pDecoderStream, 02537 CElement * pElement); 02539 02540 02541 02542 protected: 02543 CROSpec * m_pROSpec; 02544 02545 public: 02547 inline CROSpec * 02548 getROSpec (void) 02549 { 02550 return m_pROSpec; 02551 } 02552 02554 EResultCode 02555 setROSpec ( 02556 CROSpec * pValue); 02557 02558 02559 }; 02560 02561 02592 class CADD_ROSPEC_RESPONSE : public CMessage 02593 { 02594 public: 02595 CADD_ROSPEC_RESPONSE (void); 02596 ~CADD_ROSPEC_RESPONSE (void); 02597 02600 02601 static const CFieldDescriptor * const 02602 s_apFieldDescriptorTable[]; 02603 02604 static const CTypeDescriptor 02605 s_typeDescriptor; 02606 02607 void 02608 decodeFields ( 02609 CDecoderStream * pDecoderStream); 02610 02611 void 02612 assimilateSubParameters ( 02613 CErrorDetails * pError); 02614 02615 void 02616 encode ( 02617 CEncoderStream * pEncoderStream) const; 02618 02619 02620 02621 static CElement * 02622 s_construct (void); 02623 02624 static void 02625 s_decodeFields ( 02626 CDecoderStream * pDecoderStream, 02627 CElement * pElement); 02629 02630 02631 02632 protected: 02633 CLLRPStatus * m_pLLRPStatus; 02634 02635 public: 02637 inline CLLRPStatus * 02638 getLLRPStatus (void) 02639 { 02640 return m_pLLRPStatus; 02641 } 02642 02644 EResultCode 02645 setLLRPStatus ( 02646 CLLRPStatus * pValue); 02647 02648 02649 }; 02650 02651 02685 class CDELETE_ROSPEC : public CMessage 02686 { 02687 public: 02688 CDELETE_ROSPEC (void); 02689 ~CDELETE_ROSPEC (void); 02690 02693 02694 static const CFieldDescriptor * const 02695 s_apFieldDescriptorTable[]; 02696 02697 static const CTypeDescriptor 02698 s_typeDescriptor; 02699 02700 void 02701 decodeFields ( 02702 CDecoderStream * pDecoderStream); 02703 02704 void 02705 assimilateSubParameters ( 02706 CErrorDetails * pError); 02707 02708 void 02709 encode ( 02710 CEncoderStream * pEncoderStream) const; 02711 02712 02713 02714 static CElement * 02715 s_construct (void); 02716 02717 static void 02718 s_decodeFields ( 02719 CDecoderStream * pDecoderStream, 02720 CElement * pElement); 02722 02723 02724 protected: 02725 llrp_u32_t m_ROSpecID; 02726 02729 public: 02730 static const CFieldDescriptor 02731 s_fdROSpecID; 02733 02735 inline llrp_u32_t 02736 getROSpecID (void) 02737 { 02738 return m_ROSpecID; 02739 } 02740 02742 inline void 02743 setROSpecID ( 02744 llrp_u32_t value) 02745 { 02746 m_ROSpecID = value; 02747 } 02748 02749 02750 02751 }; 02752 02753 02784 class CDELETE_ROSPEC_RESPONSE : public CMessage 02785 { 02786 public: 02787 CDELETE_ROSPEC_RESPONSE (void); 02788 ~CDELETE_ROSPEC_RESPONSE (void); 02789 02792 02793 static const CFieldDescriptor * const 02794 s_apFieldDescriptorTable[]; 02795 02796 static const CTypeDescriptor 02797 s_typeDescriptor; 02798 02799 void 02800 decodeFields ( 02801 CDecoderStream * pDecoderStream); 02802 02803 void 02804 assimilateSubParameters ( 02805 CErrorDetails * pError); 02806 02807 void 02808 encode ( 02809 CEncoderStream * pEncoderStream) const; 02810 02811 02812 02813 static CElement * 02814 s_construct (void); 02815 02816 static void 02817 s_decodeFields ( 02818 CDecoderStream * pDecoderStream, 02819 CElement * pElement); 02821 02822 02823 02824 protected: 02825 CLLRPStatus * m_pLLRPStatus; 02826 02827 public: 02829 inline CLLRPStatus * 02830 getLLRPStatus (void) 02831 { 02832 return m_pLLRPStatus; 02833 } 02834 02836 EResultCode 02837 setLLRPStatus ( 02838 CLLRPStatus * pValue); 02839 02840 02841 }; 02842 02843 02877 class CSTART_ROSPEC : public CMessage 02878 { 02879 public: 02880 CSTART_ROSPEC (void); 02881 ~CSTART_ROSPEC (void); 02882 02885 02886 static const CFieldDescriptor * const 02887 s_apFieldDescriptorTable[]; 02888 02889 static const CTypeDescriptor 02890 s_typeDescriptor; 02891 02892 void 02893 decodeFields ( 02894 CDecoderStream * pDecoderStream); 02895 02896 void 02897 assimilateSubParameters ( 02898 CErrorDetails * pError); 02899 02900 void 02901 encode ( 02902 CEncoderStream * pEncoderStream) const; 02903 02904 02905 02906 static CElement * 02907 s_construct (void); 02908 02909 static void 02910 s_decodeFields ( 02911 CDecoderStream * pDecoderStream, 02912 CElement * pElement); 02914 02915 02916 protected: 02917 llrp_u32_t m_ROSpecID; 02918 02921 public: 02922 static const CFieldDescriptor 02923 s_fdROSpecID; 02925 02927 inline llrp_u32_t 02928 getROSpecID (void) 02929 { 02930 return m_ROSpecID; 02931 } 02932 02934 inline void 02935 setROSpecID ( 02936 llrp_u32_t value) 02937 { 02938 m_ROSpecID = value; 02939 } 02940 02941 02942 02943 }; 02944 02945 02976 class CSTART_ROSPEC_RESPONSE : public CMessage 02977 { 02978 public: 02979 CSTART_ROSPEC_RESPONSE (void); 02980 ~CSTART_ROSPEC_RESPONSE (void); 02981 02984 02985 static const CFieldDescriptor * const 02986 s_apFieldDescriptorTable[]; 02987 02988 static const CTypeDescriptor 02989 s_typeDescriptor; 02990 02991 void 02992 decodeFields ( 02993 CDecoderStream * pDecoderStream); 02994 02995 void 02996 assimilateSubParameters ( 02997 CErrorDetails * pError); 02998 02999 void 03000 encode ( 03001 CEncoderStream * pEncoderStream) const; 03002 03003 03004 03005 static CElement * 03006 s_construct (void); 03007 03008 static void 03009 s_decodeFields ( 03010 CDecoderStream * pDecoderStream, 03011 CElement * pElement); 03013 03014 03015 03016 protected: 03017 CLLRPStatus * m_pLLRPStatus; 03018 03019 public: 03021 inline CLLRPStatus * 03022 getLLRPStatus (void) 03023 { 03024 return m_pLLRPStatus; 03025 } 03026 03028 EResultCode 03029 setLLRPStatus ( 03030 CLLRPStatus * pValue); 03031 03032 03033 }; 03034 03035 03069 class CSTOP_ROSPEC : public CMessage 03070 { 03071 public: 03072 CSTOP_ROSPEC (void); 03073 ~CSTOP_ROSPEC (void); 03074 03077 03078 static const CFieldDescriptor * const 03079 s_apFieldDescriptorTable[]; 03080 03081 static const CTypeDescriptor 03082 s_typeDescriptor; 03083 03084 void 03085 decodeFields ( 03086 CDecoderStream * pDecoderStream); 03087 03088 void 03089 assimilateSubParameters ( 03090 CErrorDetails * pError); 03091 03092 void 03093 encode ( 03094 CEncoderStream * pEncoderStream) const; 03095 03096 03097 03098 static CElement * 03099 s_construct (void); 03100 03101 static void 03102 s_decodeFields ( 03103 CDecoderStream * pDecoderStream, 03104 CElement * pElement); 03106 03107 03108 protected: 03109 llrp_u32_t m_ROSpecID; 03110 03113 public: 03114 static const CFieldDescriptor 03115 s_fdROSpecID; 03117 03119 inline llrp_u32_t 03120 getROSpecID (void) 03121 { 03122 return m_ROSpecID; 03123 } 03124 03126 inline void 03127 setROSpecID ( 03128 llrp_u32_t value) 03129 { 03130 m_ROSpecID = value; 03131 } 03132 03133 03134 03135 }; 03136 03137 03168 class CSTOP_ROSPEC_RESPONSE : public CMessage 03169 { 03170 public: 03171 CSTOP_ROSPEC_RESPONSE (void); 03172 ~CSTOP_ROSPEC_RESPONSE (void); 03173 03176 03177 static const CFieldDescriptor * const 03178 s_apFieldDescriptorTable[]; 03179 03180 static const CTypeDescriptor 03181 s_typeDescriptor; 03182 03183 void 03184 decodeFields ( 03185 CDecoderStream * pDecoderStream); 03186 03187 void 03188 assimilateSubParameters ( 03189 CErrorDetails * pError); 03190 03191 void 03192 encode ( 03193 CEncoderStream * pEncoderStream) const; 03194 03195 03196 03197 static CElement * 03198 s_construct (void); 03199 03200 static void 03201 s_decodeFields ( 03202 CDecoderStream * pDecoderStream, 03203 CElement * pElement); 03205 03206 03207 03208 protected: 03209 CLLRPStatus * m_pLLRPStatus; 03210 03211 public: 03213 inline CLLRPStatus * 03214 getLLRPStatus (void) 03215 { 03216 return m_pLLRPStatus; 03217 } 03218 03220 EResultCode 03221 setLLRPStatus ( 03222 CLLRPStatus * pValue); 03223 03224 03225 }; 03226 03227 03261 class CENABLE_ROSPEC : public CMessage 03262 { 03263 public: 03264 CENABLE_ROSPEC (void); 03265 ~CENABLE_ROSPEC (void); 03266 03269 03270 static const CFieldDescriptor * const 03271 s_apFieldDescriptorTable[]; 03272 03273 static const CTypeDescriptor 03274 s_typeDescriptor; 03275 03276 void 03277 decodeFields ( 03278 CDecoderStream * pDecoderStream); 03279 03280 void 03281 assimilateSubParameters ( 03282 CErrorDetails * pError); 03283 03284 void 03285 encode ( 03286 CEncoderStream * pEncoderStream) const; 03287 03288 03289 03290 static CElement * 03291 s_construct (void); 03292 03293 static void 03294 s_decodeFields ( 03295 CDecoderStream * pDecoderStream, 03296 CElement * pElement); 03298 03299 03300 protected: 03301 llrp_u32_t m_ROSpecID; 03302 03305 public: 03306 static const CFieldDescriptor 03307 s_fdROSpecID; 03309 03311 inline llrp_u32_t 03312 getROSpecID (void) 03313 { 03314 return m_ROSpecID; 03315 } 03316 03318 inline void 03319 setROSpecID ( 03320 llrp_u32_t value) 03321 { 03322 m_ROSpecID = value; 03323 } 03324 03325 03326 03327 }; 03328 03329 03360 class CENABLE_ROSPEC_RESPONSE : public CMessage 03361 { 03362 public: 03363 CENABLE_ROSPEC_RESPONSE (void); 03364 ~CENABLE_ROSPEC_RESPONSE (void); 03365 03368 03369 static const CFieldDescriptor * const 03370 s_apFieldDescriptorTable[]; 03371 03372 static const CTypeDescriptor 03373 s_typeDescriptor; 03374 03375 void 03376 decodeFields ( 03377 CDecoderStream * pDecoderStream); 03378 03379 void 03380 assimilateSubParameters ( 03381 CErrorDetails * pError); 03382 03383 void 03384 encode ( 03385 CEncoderStream * pEncoderStream) const; 03386 03387 03388 03389 static CElement * 03390 s_construct (void); 03391 03392 static void 03393 s_decodeFields ( 03394 CDecoderStream * pDecoderStream, 03395 CElement * pElement); 03397 03398 03399 03400 protected: 03401 CLLRPStatus * m_pLLRPStatus; 03402 03403 public: 03405 inline CLLRPStatus * 03406 getLLRPStatus (void) 03407 { 03408 return m_pLLRPStatus; 03409 } 03410 03412 EResultCode 03413 setLLRPStatus ( 03414 CLLRPStatus * pValue); 03415 03416 03417 }; 03418 03419 03453 class CDISABLE_ROSPEC : public CMessage 03454 { 03455 public: 03456 CDISABLE_ROSPEC (void); 03457 ~CDISABLE_ROSPEC (void); 03458 03461 03462 static const CFieldDescriptor * const 03463 s_apFieldDescriptorTable[]; 03464 03465 static const CTypeDescriptor 03466 s_typeDescriptor; 03467 03468 void 03469 decodeFields ( 03470 CDecoderStream * pDecoderStream); 03471 03472 void 03473 assimilateSubParameters ( 03474 CErrorDetails * pError); 03475 03476 void 03477 encode ( 03478 CEncoderStream * pEncoderStream) const; 03479 03480 03481 03482 static CElement * 03483 s_construct (void); 03484 03485 static void 03486 s_decodeFields ( 03487 CDecoderStream * pDecoderStream, 03488 CElement * pElement); 03490 03491 03492 protected: 03493 llrp_u32_t m_ROSpecID; 03494 03497 public: 03498 static const CFieldDescriptor 03499 s_fdROSpecID; 03501 03503 inline llrp_u32_t 03504 getROSpecID (void) 03505 { 03506 return m_ROSpecID; 03507 } 03508 03510 inline void 03511 setROSpecID ( 03512 llrp_u32_t value) 03513 { 03514 m_ROSpecID = value; 03515 } 03516 03517 03518 03519 }; 03520 03521 03552 class CDISABLE_ROSPEC_RESPONSE : public CMessage 03553 { 03554 public: 03555 CDISABLE_ROSPEC_RESPONSE (void); 03556 ~CDISABLE_ROSPEC_RESPONSE (void); 03557 03560 03561 static const CFieldDescriptor * const 03562 s_apFieldDescriptorTable[]; 03563 03564 static const CTypeDescriptor 03565 s_typeDescriptor; 03566 03567 void 03568 decodeFields ( 03569 CDecoderStream * pDecoderStream); 03570 03571 void 03572 assimilateSubParameters ( 03573 CErrorDetails * pError); 03574 03575 void 03576 encode ( 03577 CEncoderStream * pEncoderStream) const; 03578 03579 03580 03581 static CElement * 03582 s_construct (void); 03583 03584 static void 03585 s_decodeFields ( 03586 CDecoderStream * pDecoderStream, 03587 CElement * pElement); 03589 03590 03591 03592 protected: 03593 CLLRPStatus * m_pLLRPStatus; 03594 03595 public: 03597 inline CLLRPStatus * 03598 getLLRPStatus (void) 03599 { 03600 return m_pLLRPStatus; 03601 } 03602 03604 EResultCode 03605 setLLRPStatus ( 03606 CLLRPStatus * pValue); 03607 03608 03609 }; 03610 03611 03641 class CGET_ROSPECS : public CMessage 03642 { 03643 public: 03644 CGET_ROSPECS (void); 03645 ~CGET_ROSPECS (void); 03646 03649 03650 static const CFieldDescriptor * const 03651 s_apFieldDescriptorTable[]; 03652 03653 static const CTypeDescriptor 03654 s_typeDescriptor; 03655 03656 void 03657 decodeFields ( 03658 CDecoderStream * pDecoderStream); 03659 03660 void 03661 assimilateSubParameters ( 03662 CErrorDetails * pError); 03663 03664 void 03665 encode ( 03666 CEncoderStream * pEncoderStream) const; 03667 03668 03669 03670 static CElement * 03671 s_construct (void); 03672 03673 static void 03674 s_decodeFields ( 03675 CDecoderStream * pDecoderStream, 03676 CElement * pElement); 03678 03679 03680 03681 }; 03682 03683 03715 class CGET_ROSPECS_RESPONSE : public CMessage 03716 { 03717 public: 03718 CGET_ROSPECS_RESPONSE (void); 03719 ~CGET_ROSPECS_RESPONSE (void); 03720 03723 03724 static const CFieldDescriptor * const 03725 s_apFieldDescriptorTable[]; 03726 03727 static const CTypeDescriptor 03728 s_typeDescriptor; 03729 03730 void 03731 decodeFields ( 03732 CDecoderStream * pDecoderStream); 03733 03734 void 03735 assimilateSubParameters ( 03736 CErrorDetails * pError); 03737 03738 void 03739 encode ( 03740 CEncoderStream * pEncoderStream) const; 03741 03742 03743 03744 static CElement * 03745 s_construct (void); 03746 03747 static void 03748 s_decodeFields ( 03749 CDecoderStream * pDecoderStream, 03750 CElement * pElement); 03752 03753 03754 03755 protected: 03756 CLLRPStatus * m_pLLRPStatus; 03757 03758 public: 03760 inline CLLRPStatus * 03761 getLLRPStatus (void) 03762 { 03763 return m_pLLRPStatus; 03764 } 03765 03767 EResultCode 03768 setLLRPStatus ( 03769 CLLRPStatus * pValue); 03770 03771 03772 protected: 03773 std::list<CROSpec *> m_listROSpec; 03774 03775 public: 03777 inline std::list<CROSpec *>::iterator 03778 beginROSpec (void) 03779 { 03780 return m_listROSpec.begin(); 03781 } 03782 03784 inline std::list<CROSpec *>::iterator 03785 endROSpec (void) 03786 { 03787 return m_listROSpec.end(); 03788 } 03789 03791 inline void 03792 clearROSpec (void) 03793 { 03794 clearSubParameterList ((tListOfParameters *) &m_listROSpec); 03795 } 03796 03798 inline int 03799 countROSpec (void) 03800 { 03801 return (int) (m_listROSpec.size()); 03802 } 03803 03804 EResultCode 03806 addROSpec ( 03807 CROSpec * pValue); 03808 03809 03810 }; 03811 03812 03852 class CADD_ACCESSSPEC : public CMessage 03853 { 03854 public: 03855 CADD_ACCESSSPEC (void); 03856 ~CADD_ACCESSSPEC (void); 03857 03860 03861 static const CFieldDescriptor * const 03862 s_apFieldDescriptorTable[]; 03863 03864 static const CTypeDescriptor 03865 s_typeDescriptor; 03866 03867 void 03868 decodeFields ( 03869 CDecoderStream * pDecoderStream); 03870 03871 void 03872 assimilateSubParameters ( 03873 CErrorDetails * pError); 03874 03875 void 03876 encode ( 03877 CEncoderStream * pEncoderStream) const; 03878 03879 03880 03881 static CElement * 03882 s_construct (void); 03883 03884 static void 03885 s_decodeFields ( 03886 CDecoderStream * pDecoderStream, 03887 CElement * pElement); 03889 03890 03891 03892 protected: 03893 CAccessSpec * m_pAccessSpec; 03894 03895 public: 03897 inline CAccessSpec * 03898 getAccessSpec (void) 03899 { 03900 return m_pAccessSpec; 03901 } 03902 03904 EResultCode 03905 setAccessSpec ( 03906 CAccessSpec * pValue); 03907 03908 03909 }; 03910 03911 03942 class CADD_ACCESSSPEC_RESPONSE : public CMessage 03943 { 03944 public: 03945 CADD_ACCESSSPEC_RESPONSE (void); 03946 ~CADD_ACCESSSPEC_RESPONSE (void); 03947 03950 03951 static const CFieldDescriptor * const 03952 s_apFieldDescriptorTable[]; 03953 03954 static const CTypeDescriptor 03955 s_typeDescriptor; 03956 03957 void 03958 decodeFields ( 03959 CDecoderStream * pDecoderStream); 03960 03961 void 03962 assimilateSubParameters ( 03963 CErrorDetails * pError); 03964 03965 void 03966 encode ( 03967 CEncoderStream * pEncoderStream) const; 03968 03969 03970 03971 static CElement * 03972 s_construct (void); 03973 03974 static void 03975 s_decodeFields ( 03976 CDecoderStream * pDecoderStream, 03977 CElement * pElement); 03979 03980 03981 03982 protected: 03983 CLLRPStatus * m_pLLRPStatus; 03984 03985 public: 03987 inline CLLRPStatus * 03988 getLLRPStatus (void) 03989 { 03990 return m_pLLRPStatus; 03991 } 03992 03994 EResultCode 03995 setLLRPStatus ( 03996 CLLRPStatus * pValue); 03997 03998 03999 }; 04000 04001 04035 class CDELETE_ACCESSSPEC : public CMessage 04036 { 04037 public: 04038 CDELETE_ACCESSSPEC (void); 04039 ~CDELETE_ACCESSSPEC (void); 04040 04043 04044 static const CFieldDescriptor * const 04045 s_apFieldDescriptorTable[]; 04046 04047 static const CTypeDescriptor 04048 s_typeDescriptor; 04049 04050 void 04051 decodeFields ( 04052 CDecoderStream * pDecoderStream); 04053 04054 void 04055 assimilateSubParameters ( 04056 CErrorDetails * pError); 04057 04058 void 04059 encode ( 04060 CEncoderStream * pEncoderStream) const; 04061 04062 04063 04064 static CElement * 04065 s_construct (void); 04066 04067 static void 04068 s_decodeFields ( 04069 CDecoderStream * pDecoderStream, 04070 CElement * pElement); 04072 04073 04074 protected: 04075 llrp_u32_t m_AccessSpecID; 04076 04079 public: 04080 static const CFieldDescriptor 04081 s_fdAccessSpecID; 04083 04085 inline llrp_u32_t 04086 getAccessSpecID (void) 04087 { 04088 return m_AccessSpecID; 04089 } 04090 04092 inline void 04093 setAccessSpecID ( 04094 llrp_u32_t value) 04095 { 04096 m_AccessSpecID = value; 04097 } 04098 04099 04100 04101 }; 04102 04103 04134 class CDELETE_ACCESSSPEC_RESPONSE : public CMessage 04135 { 04136 public: 04137 CDELETE_ACCESSSPEC_RESPONSE (void); 04138 ~CDELETE_ACCESSSPEC_RESPONSE (void); 04139 04142 04143 static const CFieldDescriptor * const 04144 s_apFieldDescriptorTable[]; 04145 04146 static const CTypeDescriptor 04147 s_typeDescriptor; 04148 04149 void 04150 decodeFields ( 04151 CDecoderStream * pDecoderStream); 04152 04153 void 04154 assimilateSubParameters ( 04155 CErrorDetails * pError); 04156 04157 void 04158 encode ( 04159 CEncoderStream * pEncoderStream) const; 04160 04161 04162 04163 static CElement * 04164 s_construct (void); 04165 04166 static void 04167 s_decodeFields ( 04168 CDecoderStream * pDecoderStream, 04169 CElement * pElement); 04171 04172 04173 04174 protected: 04175 CLLRPStatus * m_pLLRPStatus; 04176 04177 public: 04179 inline CLLRPStatus * 04180 getLLRPStatus (void) 04181 { 04182 return m_pLLRPStatus; 04183 } 04184 04186 EResultCode 04187 setLLRPStatus ( 04188 CLLRPStatus * pValue); 04189 04190 04191 }; 04192 04193 04227 class CENABLE_ACCESSSPEC : public CMessage 04228 { 04229 public: 04230 CENABLE_ACCESSSPEC (void); 04231 ~CENABLE_ACCESSSPEC (void); 04232 04235 04236 static const CFieldDescriptor * const 04237 s_apFieldDescriptorTable[]; 04238 04239 static const CTypeDescriptor 04240 s_typeDescriptor; 04241 04242 void 04243 decodeFields ( 04244 CDecoderStream * pDecoderStream); 04245 04246 void 04247 assimilateSubParameters ( 04248 CErrorDetails * pError); 04249 04250 void 04251 encode ( 04252 CEncoderStream * pEncoderStream) const; 04253 04254 04255 04256 static CElement * 04257 s_construct (void); 04258 04259 static void 04260 s_decodeFields ( 04261 CDecoderStream * pDecoderStream, 04262 CElement * pElement); 04264 04265 04266 protected: 04267 llrp_u32_t m_AccessSpecID; 04268 04271 public: 04272 static const CFieldDescriptor 04273 s_fdAccessSpecID; 04275 04277 inline llrp_u32_t 04278 getAccessSpecID (void) 04279 { 04280 return m_AccessSpecID; 04281 } 04282 04284 inline void 04285 setAccessSpecID ( 04286 llrp_u32_t value) 04287 { 04288 m_AccessSpecID = value; 04289 } 04290 04291 04292 04293 }; 04294 04295 04326 class CENABLE_ACCESSSPEC_RESPONSE : public CMessage 04327 { 04328 public: 04329 CENABLE_ACCESSSPEC_RESPONSE (void); 04330 ~CENABLE_ACCESSSPEC_RESPONSE (void); 04331 04334 04335 static const CFieldDescriptor * const 04336 s_apFieldDescriptorTable[]; 04337 04338 static const CTypeDescriptor 04339 s_typeDescriptor; 04340 04341 void 04342 decodeFields ( 04343 CDecoderStream * pDecoderStream); 04344 04345 void 04346 assimilateSubParameters ( 04347 CErrorDetails * pError); 04348 04349 void 04350 encode ( 04351 CEncoderStream * pEncoderStream) const; 04352 04353 04354 04355 static CElement * 04356 s_construct (void); 04357 04358 static void 04359 s_decodeFields ( 04360 CDecoderStream * pDecoderStream, 04361 CElement * pElement); 04363 04364 04365 04366 protected: 04367 CLLRPStatus * m_pLLRPStatus; 04368 04369 public: 04371 inline CLLRPStatus * 04372 getLLRPStatus (void) 04373 { 04374 return m_pLLRPStatus; 04375 } 04376 04378 EResultCode 04379 setLLRPStatus ( 04380 CLLRPStatus * pValue); 04381 04382 04383 }; 04384 04385 04419 class CDISABLE_ACCESSSPEC : public CMessage 04420 { 04421 public: 04422 CDISABLE_ACCESSSPEC (void); 04423 ~CDISABLE_ACCESSSPEC (void); 04424 04427 04428 static const CFieldDescriptor * const 04429 s_apFieldDescriptorTable[]; 04430 04431 static const CTypeDescriptor 04432 s_typeDescriptor; 04433 04434 void 04435 decodeFields ( 04436 CDecoderStream * pDecoderStream); 04437 04438 void 04439 assimilateSubParameters ( 04440 CErrorDetails * pError); 04441 04442 void 04443 encode ( 04444 CEncoderStream * pEncoderStream) const; 04445 04446 04447 04448 static CElement * 04449 s_construct (void); 04450 04451 static void 04452 s_decodeFields ( 04453 CDecoderStream * pDecoderStream, 04454 CElement * pElement); 04456 04457 04458 protected: 04459 llrp_u32_t m_AccessSpecID; 04460 04463 public: 04464 static const CFieldDescriptor 04465 s_fdAccessSpecID; 04467 04469 inline llrp_u32_t 04470 getAccessSpecID (void) 04471 { 04472 return m_AccessSpecID; 04473 } 04474 04476 inline void 04477 setAccessSpecID ( 04478 llrp_u32_t value) 04479 { 04480 m_AccessSpecID = value; 04481 } 04482 04483 04484 04485 }; 04486 04487 04518 class CDISABLE_ACCESSSPEC_RESPONSE : public CMessage 04519 { 04520 public: 04521 CDISABLE_ACCESSSPEC_RESPONSE (void); 04522 ~CDISABLE_ACCESSSPEC_RESPONSE (void); 04523 04526 04527 static const CFieldDescriptor * const 04528 s_apFieldDescriptorTable[]; 04529 04530 static const CTypeDescriptor 04531 s_typeDescriptor; 04532 04533 void 04534 decodeFields ( 04535 CDecoderStream * pDecoderStream); 04536 04537 void 04538 assimilateSubParameters ( 04539 CErrorDetails * pError); 04540 04541 void 04542 encode ( 04543 CEncoderStream * pEncoderStream) const; 04544 04545 04546 04547 static CElement * 04548 s_construct (void); 04549 04550 static void 04551 s_decodeFields ( 04552 CDecoderStream * pDecoderStream, 04553 CElement * pElement); 04555 04556 04557 04558 protected: 04559 CLLRPStatus * m_pLLRPStatus; 04560 04561 public: 04563 inline CLLRPStatus * 04564 getLLRPStatus (void) 04565 { 04566 return m_pLLRPStatus; 04567 } 04568 04570 EResultCode 04571 setLLRPStatus ( 04572 CLLRPStatus * pValue); 04573 04574 04575 }; 04576 04577 04607 class CGET_ACCESSSPECS : public CMessage 04608 { 04609 public: 04610 CGET_ACCESSSPECS (void); 04611 ~CGET_ACCESSSPECS (void); 04612 04615 04616 static const CFieldDescriptor * const 04617 s_apFieldDescriptorTable[]; 04618 04619 static const CTypeDescriptor 04620 s_typeDescriptor; 04621 04622 void 04623 decodeFields ( 04624 CDecoderStream * pDecoderStream); 04625 04626 void 04627 assimilateSubParameters ( 04628 CErrorDetails * pError); 04629 04630 void 04631 encode ( 04632 CEncoderStream * pEncoderStream) const; 04633 04634 04635 04636 static CElement * 04637 s_construct (void); 04638 04639 static void 04640 s_decodeFields ( 04641 CDecoderStream * pDecoderStream, 04642 CElement * pElement); 04644 04645 04646 04647 }; 04648 04649 04681 class CGET_ACCESSSPECS_RESPONSE : public CMessage 04682 { 04683 public: 04684 CGET_ACCESSSPECS_RESPONSE (void); 04685 ~CGET_ACCESSSPECS_RESPONSE (void); 04686 04689 04690 static const CFieldDescriptor * const 04691 s_apFieldDescriptorTable[]; 04692 04693 static const CTypeDescriptor 04694 s_typeDescriptor; 04695 04696 void 04697 decodeFields ( 04698 CDecoderStream * pDecoderStream); 04699 04700 void 04701 assimilateSubParameters ( 04702 CErrorDetails * pError); 04703 04704 void 04705 encode ( 04706 CEncoderStream * pEncoderStream) const; 04707 04708 04709 04710 static CElement * 04711 s_construct (void); 04712 04713 static void 04714 s_decodeFields ( 04715 CDecoderStream * pDecoderStream, 04716 CElement * pElement); 04718 04719 04720 04721 protected: 04722 CLLRPStatus * m_pLLRPStatus; 04723 04724 public: 04726 inline CLLRPStatus * 04727 getLLRPStatus (void) 04728 { 04729 return m_pLLRPStatus; 04730 } 04731 04733 EResultCode 04734 setLLRPStatus ( 04735 CLLRPStatus * pValue); 04736 04737 04738 protected: 04739 std::list<CAccessSpec *> m_listAccessSpec; 04740 04741 public: 04743 inline std::list<CAccessSpec *>::iterator 04744 beginAccessSpec (void) 04745 { 04746 return m_listAccessSpec.begin(); 04747 } 04748 04750 inline std::list<CAccessSpec *>::iterator 04751 endAccessSpec (void) 04752 { 04753 return m_listAccessSpec.end(); 04754 } 04755 04757 inline void 04758 clearAccessSpec (void) 04759 { 04760 clearSubParameterList ((tListOfParameters *) &m_listAccessSpec); 04761 } 04762 04764 inline int 04765 countAccessSpec (void) 04766 { 04767 return (int) (m_listAccessSpec.size()); 04768 } 04769 04770 EResultCode 04772 addAccessSpec ( 04773 CAccessSpec * pValue); 04774 04775 04776 }; 04777 04778 04809 class CCLIENT_REQUEST_OP : public CMessage 04810 { 04811 public: 04812 CCLIENT_REQUEST_OP (void); 04813 ~CCLIENT_REQUEST_OP (void); 04814 04817 04818 static const CFieldDescriptor * const 04819 s_apFieldDescriptorTable[]; 04820 04821 static const CTypeDescriptor 04822 s_typeDescriptor; 04823 04824 void 04825 decodeFields ( 04826 CDecoderStream * pDecoderStream); 04827 04828 void 04829 assimilateSubParameters ( 04830 CErrorDetails * pError); 04831 04832 void 04833 encode ( 04834 CEncoderStream * pEncoderStream) const; 04835 04836 04837 04838 static CElement * 04839 s_construct (void); 04840 04841 static void 04842 s_decodeFields ( 04843 CDecoderStream * pDecoderStream, 04844 CElement * pElement); 04846 04847 04848 04849 protected: 04850 CTagReportData * m_pTagReportData; 04851 04852 public: 04854 inline CTagReportData * 04855 getTagReportData (void) 04856 { 04857 return m_pTagReportData; 04858 } 04859 04861 EResultCode 04862 setTagReportData ( 04863 CTagReportData * pValue); 04864 04865 04866 }; 04867 04868 04899 class CCLIENT_REQUEST_OP_RESPONSE : public CMessage 04900 { 04901 public: 04902 CCLIENT_REQUEST_OP_RESPONSE (void); 04903 ~CCLIENT_REQUEST_OP_RESPONSE (void); 04904 04907 04908 static const CFieldDescriptor * const 04909 s_apFieldDescriptorTable[]; 04910 04911 static const CTypeDescriptor 04912 s_typeDescriptor; 04913 04914 void 04915 decodeFields ( 04916 CDecoderStream * pDecoderStream); 04917 04918 void 04919 assimilateSubParameters ( 04920 CErrorDetails * pError); 04921 04922 void 04923 encode ( 04924 CEncoderStream * pEncoderStream) const; 04925 04926 04927 04928 static CElement * 04929 s_construct (void); 04930 04931 static void 04932 s_decodeFields ( 04933 CDecoderStream * pDecoderStream, 04934 CElement * pElement); 04936 04937 04938 04939 protected: 04940 CClientRequestResponse * m_pClientRequestResponse; 04941 04942 public: 04944 inline CClientRequestResponse * 04945 getClientRequestResponse (void) 04946 { 04947 return m_pClientRequestResponse; 04948 } 04949 04951 EResultCode 04952 setClientRequestResponse ( 04953 CClientRequestResponse * pValue); 04954 04955 04956 }; 04957 04958 04993 class CGET_READER_CONFIG : public CMessage 04994 { 04995 public: 04996 CGET_READER_CONFIG (void); 04997 ~CGET_READER_CONFIG (void); 04998 05001 05002 static const CFieldDescriptor * const 05003 s_apFieldDescriptorTable[]; 05004 05005 static const CTypeDescriptor 05006 s_typeDescriptor; 05007 05008 void 05009 decodeFields ( 05010 CDecoderStream * pDecoderStream); 05011 05012 void 05013 assimilateSubParameters ( 05014 CErrorDetails * pError); 05015 05016 void 05017 encode ( 05018 CEncoderStream * pEncoderStream) const; 05019 05020 05021 05022 static CElement * 05023 s_construct (void); 05024 05025 static void 05026 s_decodeFields ( 05027 CDecoderStream * pDecoderStream, 05028 CElement * pElement); 05030 05031 05032 protected: 05033 llrp_u16_t m_AntennaID; 05034 05037 public: 05038 static const CFieldDescriptor 05039 s_fdAntennaID; 05041 05043 inline llrp_u16_t 05044 getAntennaID (void) 05045 { 05046 return m_AntennaID; 05047 } 05048 05050 inline void 05051 setAntennaID ( 05052 llrp_u16_t value) 05053 { 05054 m_AntennaID = value; 05055 } 05056 05057 05058 protected: 05059 EGetReaderConfigRequestedData m_eRequestedData; 05060 05063 public: 05064 static const CFieldDescriptor 05065 s_fdRequestedData; 05067 05069 inline EGetReaderConfigRequestedData 05070 getRequestedData (void) 05071 { 05072 return m_eRequestedData; 05073 } 05074 05076 inline void 05077 setRequestedData ( 05078 EGetReaderConfigRequestedData value) 05079 { 05080 m_eRequestedData = value; 05081 } 05082 05083 05084 protected: 05085 llrp_u16_t m_GPIPortNum; 05086 05089 public: 05090 static const CFieldDescriptor 05091 s_fdGPIPortNum; 05093 05095 inline llrp_u16_t 05096 getGPIPortNum (void) 05097 { 05098 return m_GPIPortNum; 05099 } 05100 05102 inline void 05103 setGPIPortNum ( 05104 llrp_u16_t value) 05105 { 05106 m_GPIPortNum = value; 05107 } 05108 05109 05110 protected: 05111 llrp_u16_t m_GPOPortNum; 05112 05115 public: 05116 static const CFieldDescriptor 05117 s_fdGPOPortNum; 05119 05121 inline llrp_u16_t 05122 getGPOPortNum (void) 05123 { 05124 return m_GPOPortNum; 05125 } 05126 05128 inline void 05129 setGPOPortNum ( 05130 llrp_u16_t value) 05131 { 05132 m_GPOPortNum = value; 05133 } 05134 05135 05136 05137 protected: 05138 std::list<CParameter *> m_listCustom; 05139 05140 public: 05142 inline std::list<CParameter *>::iterator 05143 beginCustom (void) 05144 { 05145 return m_listCustom.begin(); 05146 } 05147 05149 inline std::list<CParameter *>::iterator 05150 endCustom (void) 05151 { 05152 return m_listCustom.end(); 05153 } 05154 05156 inline void 05157 clearCustom (void) 05158 { 05159 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05160 } 05161 05163 inline int 05164 countCustom (void) 05165 { 05166 return (int) (m_listCustom.size()); 05167 } 05168 05169 EResultCode 05171 addCustom ( 05172 CParameter * pValue); 05173 05174 05175 }; 05176 05177 05238 class CGET_READER_CONFIG_RESPONSE : public CMessage 05239 { 05240 public: 05241 CGET_READER_CONFIG_RESPONSE (void); 05242 ~CGET_READER_CONFIG_RESPONSE (void); 05243 05246 05247 static const CFieldDescriptor * const 05248 s_apFieldDescriptorTable[]; 05249 05250 static const CTypeDescriptor 05251 s_typeDescriptor; 05252 05253 void 05254 decodeFields ( 05255 CDecoderStream * pDecoderStream); 05256 05257 void 05258 assimilateSubParameters ( 05259 CErrorDetails * pError); 05260 05261 void 05262 encode ( 05263 CEncoderStream * pEncoderStream) const; 05264 05265 05266 05267 static CElement * 05268 s_construct (void); 05269 05270 static void 05271 s_decodeFields ( 05272 CDecoderStream * pDecoderStream, 05273 CElement * pElement); 05275 05276 05277 05278 protected: 05279 CLLRPStatus * m_pLLRPStatus; 05280 05281 public: 05283 inline CLLRPStatus * 05284 getLLRPStatus (void) 05285 { 05286 return m_pLLRPStatus; 05287 } 05288 05290 EResultCode 05291 setLLRPStatus ( 05292 CLLRPStatus * pValue); 05293 05294 05295 protected: 05296 CIdentification * m_pIdentification; 05297 05298 public: 05300 inline CIdentification * 05301 getIdentification (void) 05302 { 05303 return m_pIdentification; 05304 } 05305 05307 EResultCode 05308 setIdentification ( 05309 CIdentification * pValue); 05310 05311 05312 protected: 05313 std::list<CAntennaProperties *> m_listAntennaProperties; 05314 05315 public: 05317 inline std::list<CAntennaProperties *>::iterator 05318 beginAntennaProperties (void) 05319 { 05320 return m_listAntennaProperties.begin(); 05321 } 05322 05324 inline std::list<CAntennaProperties *>::iterator 05325 endAntennaProperties (void) 05326 { 05327 return m_listAntennaProperties.end(); 05328 } 05329 05331 inline void 05332 clearAntennaProperties (void) 05333 { 05334 clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties); 05335 } 05336 05338 inline int 05339 countAntennaProperties (void) 05340 { 05341 return (int) (m_listAntennaProperties.size()); 05342 } 05343 05344 EResultCode 05346 addAntennaProperties ( 05347 CAntennaProperties * pValue); 05348 05349 05350 protected: 05351 std::list<CAntennaConfiguration *> m_listAntennaConfiguration; 05352 05353 public: 05355 inline std::list<CAntennaConfiguration *>::iterator 05356 beginAntennaConfiguration (void) 05357 { 05358 return m_listAntennaConfiguration.begin(); 05359 } 05360 05362 inline std::list<CAntennaConfiguration *>::iterator 05363 endAntennaConfiguration (void) 05364 { 05365 return m_listAntennaConfiguration.end(); 05366 } 05367 05369 inline void 05370 clearAntennaConfiguration (void) 05371 { 05372 clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration); 05373 } 05374 05376 inline int 05377 countAntennaConfiguration (void) 05378 { 05379 return (int) (m_listAntennaConfiguration.size()); 05380 } 05381 05382 EResultCode 05384 addAntennaConfiguration ( 05385 CAntennaConfiguration * pValue); 05386 05387 05388 protected: 05389 CReaderEventNotificationSpec * m_pReaderEventNotificationSpec; 05390 05391 public: 05393 inline CReaderEventNotificationSpec * 05394 getReaderEventNotificationSpec (void) 05395 { 05396 return m_pReaderEventNotificationSpec; 05397 } 05398 05400 EResultCode 05401 setReaderEventNotificationSpec ( 05402 CReaderEventNotificationSpec * pValue); 05403 05404 05405 protected: 05406 CROReportSpec * m_pROReportSpec; 05407 05408 public: 05410 inline CROReportSpec * 05411 getROReportSpec (void) 05412 { 05413 return m_pROReportSpec; 05414 } 05415 05417 EResultCode 05418 setROReportSpec ( 05419 CROReportSpec * pValue); 05420 05421 05422 protected: 05423 CAccessReportSpec * m_pAccessReportSpec; 05424 05425 public: 05427 inline CAccessReportSpec * 05428 getAccessReportSpec (void) 05429 { 05430 return m_pAccessReportSpec; 05431 } 05432 05434 EResultCode 05435 setAccessReportSpec ( 05436 CAccessReportSpec * pValue); 05437 05438 05439 protected: 05440 CLLRPConfigurationStateValue * m_pLLRPConfigurationStateValue; 05441 05442 public: 05444 inline CLLRPConfigurationStateValue * 05445 getLLRPConfigurationStateValue (void) 05446 { 05447 return m_pLLRPConfigurationStateValue; 05448 } 05449 05451 EResultCode 05452 setLLRPConfigurationStateValue ( 05453 CLLRPConfigurationStateValue * pValue); 05454 05455 05456 protected: 05457 CKeepaliveSpec * m_pKeepaliveSpec; 05458 05459 public: 05461 inline CKeepaliveSpec * 05462 getKeepaliveSpec (void) 05463 { 05464 return m_pKeepaliveSpec; 05465 } 05466 05468 EResultCode 05469 setKeepaliveSpec ( 05470 CKeepaliveSpec * pValue); 05471 05472 05473 protected: 05474 std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState; 05475 05476 public: 05478 inline std::list<CGPIPortCurrentState *>::iterator 05479 beginGPIPortCurrentState (void) 05480 { 05481 return m_listGPIPortCurrentState.begin(); 05482 } 05483 05485 inline std::list<CGPIPortCurrentState *>::iterator 05486 endGPIPortCurrentState (void) 05487 { 05488 return m_listGPIPortCurrentState.end(); 05489 } 05490 05492 inline void 05493 clearGPIPortCurrentState (void) 05494 { 05495 clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState); 05496 } 05497 05499 inline int 05500 countGPIPortCurrentState (void) 05501 { 05502 return (int) (m_listGPIPortCurrentState.size()); 05503 } 05504 05505 EResultCode 05507 addGPIPortCurrentState ( 05508 CGPIPortCurrentState * pValue); 05509 05510 05511 protected: 05512 std::list<CGPOWriteData *> m_listGPOWriteData; 05513 05514 public: 05516 inline std::list<CGPOWriteData *>::iterator 05517 beginGPOWriteData (void) 05518 { 05519 return m_listGPOWriteData.begin(); 05520 } 05521 05523 inline std::list<CGPOWriteData *>::iterator 05524 endGPOWriteData (void) 05525 { 05526 return m_listGPOWriteData.end(); 05527 } 05528 05530 inline void 05531 clearGPOWriteData (void) 05532 { 05533 clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData); 05534 } 05535 05537 inline int 05538 countGPOWriteData (void) 05539 { 05540 return (int) (m_listGPOWriteData.size()); 05541 } 05542 05543 EResultCode 05545 addGPOWriteData ( 05546 CGPOWriteData * pValue); 05547 05548 05549 protected: 05550 CEventsAndReports * m_pEventsAndReports; 05551 05552 public: 05554 inline CEventsAndReports * 05555 getEventsAndReports (void) 05556 { 05557 return m_pEventsAndReports; 05558 } 05559 05561 EResultCode 05562 setEventsAndReports ( 05563 CEventsAndReports * pValue); 05564 05565 05566 protected: 05567 std::list<CParameter *> m_listCustom; 05568 05569 public: 05571 inline std::list<CParameter *>::iterator 05572 beginCustom (void) 05573 { 05574 return m_listCustom.begin(); 05575 } 05576 05578 inline std::list<CParameter *>::iterator 05579 endCustom (void) 05580 { 05581 return m_listCustom.end(); 05582 } 05583 05585 inline void 05586 clearCustom (void) 05587 { 05588 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05589 } 05590 05592 inline int 05593 countCustom (void) 05594 { 05595 return (int) (m_listCustom.size()); 05596 } 05597 05598 EResultCode 05600 addCustom ( 05601 CParameter * pValue); 05602 05603 05604 }; 05605 05606 05656 class CSET_READER_CONFIG : public CMessage 05657 { 05658 public: 05659 CSET_READER_CONFIG (void); 05660 ~CSET_READER_CONFIG (void); 05661 05664 05665 static const CFieldDescriptor * const 05666 s_apFieldDescriptorTable[]; 05667 05668 static const CTypeDescriptor 05669 s_typeDescriptor; 05670 05671 void 05672 decodeFields ( 05673 CDecoderStream * pDecoderStream); 05674 05675 void 05676 assimilateSubParameters ( 05677 CErrorDetails * pError); 05678 05679 void 05680 encode ( 05681 CEncoderStream * pEncoderStream) const; 05682 05683 05684 05685 static CElement * 05686 s_construct (void); 05687 05688 static void 05689 s_decodeFields ( 05690 CDecoderStream * pDecoderStream, 05691 CElement * pElement); 05693 05694 05695 protected: 05696 llrp_u1_t m_ResetToFactoryDefault; 05697 05700 public: 05701 static const CFieldDescriptor 05702 s_fdResetToFactoryDefault; 05704 05706 inline llrp_u1_t 05707 getResetToFactoryDefault (void) 05708 { 05709 return m_ResetToFactoryDefault; 05710 } 05711 05713 inline void 05714 setResetToFactoryDefault ( 05715 llrp_u1_t value) 05716 { 05717 m_ResetToFactoryDefault = value; 05718 } 05719 05720 05721 05722 protected: 05723 CReaderEventNotificationSpec * m_pReaderEventNotificationSpec; 05724 05725 public: 05727 inline CReaderEventNotificationSpec * 05728 getReaderEventNotificationSpec (void) 05729 { 05730 return m_pReaderEventNotificationSpec; 05731 } 05732 05734 EResultCode 05735 setReaderEventNotificationSpec ( 05736 CReaderEventNotificationSpec * pValue); 05737 05738 05739 protected: 05740 std::list<CAntennaProperties *> m_listAntennaProperties; 05741 05742 public: 05744 inline std::list<CAntennaProperties *>::iterator 05745 beginAntennaProperties (void) 05746 { 05747 return m_listAntennaProperties.begin(); 05748 } 05749 05751 inline std::list<CAntennaProperties *>::iterator 05752 endAntennaProperties (void) 05753 { 05754 return m_listAntennaProperties.end(); 05755 } 05756 05758 inline void 05759 clearAntennaProperties (void) 05760 { 05761 clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties); 05762 } 05763 05765 inline int 05766 countAntennaProperties (void) 05767 { 05768 return (int) (m_listAntennaProperties.size()); 05769 } 05770 05771 EResultCode 05773 addAntennaProperties ( 05774 CAntennaProperties * pValue); 05775 05776 05777 protected: 05778 std::list<CAntennaConfiguration *> m_listAntennaConfiguration; 05779 05780 public: 05782 inline std::list<CAntennaConfiguration *>::iterator 05783 beginAntennaConfiguration (void) 05784 { 05785 return m_listAntennaConfiguration.begin(); 05786 } 05787 05789 inline std::list<CAntennaConfiguration *>::iterator 05790 endAntennaConfiguration (void) 05791 { 05792 return m_listAntennaConfiguration.end(); 05793 } 05794 05796 inline void 05797 clearAntennaConfiguration (void) 05798 { 05799 clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration); 05800 } 05801 05803 inline int 05804 countAntennaConfiguration (void) 05805 { 05806 return (int) (m_listAntennaConfiguration.size()); 05807 } 05808 05809 EResultCode 05811 addAntennaConfiguration ( 05812 CAntennaConfiguration * pValue); 05813 05814 05815 protected: 05816 CROReportSpec * m_pROReportSpec; 05817 05818 public: 05820 inline CROReportSpec * 05821 getROReportSpec (void) 05822 { 05823 return m_pROReportSpec; 05824 } 05825 05827 EResultCode 05828 setROReportSpec ( 05829 CROReportSpec * pValue); 05830 05831 05832 protected: 05833 CAccessReportSpec * m_pAccessReportSpec; 05834 05835 public: 05837 inline CAccessReportSpec * 05838 getAccessReportSpec (void) 05839 { 05840 return m_pAccessReportSpec; 05841 } 05842 05844 EResultCode 05845 setAccessReportSpec ( 05846 CAccessReportSpec * pValue); 05847 05848 05849 protected: 05850 CKeepaliveSpec * m_pKeepaliveSpec; 05851 05852 public: 05854 inline CKeepaliveSpec * 05855 getKeepaliveSpec (void) 05856 { 05857 return m_pKeepaliveSpec; 05858 } 05859 05861 EResultCode 05862 setKeepaliveSpec ( 05863 CKeepaliveSpec * pValue); 05864 05865 05866 protected: 05867 std::list<CGPOWriteData *> m_listGPOWriteData; 05868 05869 public: 05871 inline std::list<CGPOWriteData *>::iterator 05872 beginGPOWriteData (void) 05873 { 05874 return m_listGPOWriteData.begin(); 05875 } 05876 05878 inline std::list<CGPOWriteData *>::iterator 05879 endGPOWriteData (void) 05880 { 05881 return m_listGPOWriteData.end(); 05882 } 05883 05885 inline void 05886 clearGPOWriteData (void) 05887 { 05888 clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData); 05889 } 05890 05892 inline int 05893 countGPOWriteData (void) 05894 { 05895 return (int) (m_listGPOWriteData.size()); 05896 } 05897 05898 EResultCode 05900 addGPOWriteData ( 05901 CGPOWriteData * pValue); 05902 05903 05904 protected: 05905 std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState; 05906 05907 public: 05909 inline std::list<CGPIPortCurrentState *>::iterator 05910 beginGPIPortCurrentState (void) 05911 { 05912 return m_listGPIPortCurrentState.begin(); 05913 } 05914 05916 inline std::list<CGPIPortCurrentState *>::iterator 05917 endGPIPortCurrentState (void) 05918 { 05919 return m_listGPIPortCurrentState.end(); 05920 } 05921 05923 inline void 05924 clearGPIPortCurrentState (void) 05925 { 05926 clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState); 05927 } 05928 05930 inline int 05931 countGPIPortCurrentState (void) 05932 { 05933 return (int) (m_listGPIPortCurrentState.size()); 05934 } 05935 05936 EResultCode 05938 addGPIPortCurrentState ( 05939 CGPIPortCurrentState * pValue); 05940 05941 05942 protected: 05943 CEventsAndReports * m_pEventsAndReports; 05944 05945 public: 05947 inline CEventsAndReports * 05948 getEventsAndReports (void) 05949 { 05950 return m_pEventsAndReports; 05951 } 05952 05954 EResultCode 05955 setEventsAndReports ( 05956 CEventsAndReports * pValue); 05957 05958 05959 protected: 05960 std::list<CParameter *> m_listCustom; 05961 05962 public: 05964 inline std::list<CParameter *>::iterator 05965 beginCustom (void) 05966 { 05967 return m_listCustom.begin(); 05968 } 05969 05971 inline std::list<CParameter *>::iterator 05972 endCustom (void) 05973 { 05974 return m_listCustom.end(); 05975 } 05976 05978 inline void 05979 clearCustom (void) 05980 { 05981 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05982 } 05983 05985 inline int 05986 countCustom (void) 05987 { 05988 return (int) (m_listCustom.size()); 05989 } 05990 05991 EResultCode 05993 addCustom ( 05994 CParameter * pValue); 05995 05996 05997 }; 05998 05999 06030 class CSET_READER_CONFIG_RESPONSE : public CMessage 06031 { 06032 public: 06033 CSET_READER_CONFIG_RESPONSE (void); 06034 ~CSET_READER_CONFIG_RESPONSE (void); 06035 06038 06039 static const CFieldDescriptor * const 06040 s_apFieldDescriptorTable[]; 06041 06042 static const CTypeDescriptor 06043 s_typeDescriptor; 06044 06045 void 06046 decodeFields ( 06047 CDecoderStream * pDecoderStream); 06048 06049 void 06050 assimilateSubParameters ( 06051 CErrorDetails * pError); 06052 06053 void 06054 encode ( 06055 CEncoderStream * pEncoderStream) const; 06056 06057 06058 06059 static CElement * 06060 s_construct (void); 06061 06062 static void 06063 s_decodeFields ( 06064 CDecoderStream * pDecoderStream, 06065 CElement * pElement); 06067 06068 06069 06070 protected: 06071 CLLRPStatus * m_pLLRPStatus; 06072 06073 public: 06075 inline CLLRPStatus * 06076 getLLRPStatus (void) 06077 { 06078 return m_pLLRPStatus; 06079 } 06080 06082 EResultCode 06083 setLLRPStatus ( 06084 CLLRPStatus * pValue); 06085 06086 06087 }; 06088 06089 06131 class CCLOSE_CONNECTION : public CMessage 06132 { 06133 public: 06134 CCLOSE_CONNECTION (void); 06135 ~CCLOSE_CONNECTION (void); 06136 06139 06140 static const CFieldDescriptor * const 06141 s_apFieldDescriptorTable[]; 06142 06143 static const CTypeDescriptor 06144 s_typeDescriptor; 06145 06146 void 06147 decodeFields ( 06148 CDecoderStream * pDecoderStream); 06149 06150 void 06151 assimilateSubParameters ( 06152 CErrorDetails * pError); 06153 06154 void 06155 encode ( 06156 CEncoderStream * pEncoderStream) const; 06157 06158 06159 06160 static CElement * 06161 s_construct (void); 06162 06163 static void 06164 s_decodeFields ( 06165 CDecoderStream * pDecoderStream, 06166 CElement * pElement); 06168 06169 06170 06171 }; 06172 06173 06208 class CCLOSE_CONNECTION_RESPONSE : public CMessage 06209 { 06210 public: 06211 CCLOSE_CONNECTION_RESPONSE (void); 06212 ~CCLOSE_CONNECTION_RESPONSE (void); 06213 06216 06217 static const CFieldDescriptor * const 06218 s_apFieldDescriptorTable[]; 06219 06220 static const CTypeDescriptor 06221 s_typeDescriptor; 06222 06223 void 06224 decodeFields ( 06225 CDecoderStream * pDecoderStream); 06226 06227 void 06228 assimilateSubParameters ( 06229 CErrorDetails * pError); 06230 06231 void 06232 encode ( 06233 CEncoderStream * pEncoderStream) const; 06234 06235 06236 06237 static CElement * 06238 s_construct (void); 06239 06240 static void 06241 s_decodeFields ( 06242 CDecoderStream * pDecoderStream, 06243 CElement * pElement); 06245 06246 06247 06248 protected: 06249 CLLRPStatus * m_pLLRPStatus; 06250 06251 public: 06253 inline CLLRPStatus * 06254 getLLRPStatus (void) 06255 { 06256 return m_pLLRPStatus; 06257 } 06258 06260 EResultCode 06261 setLLRPStatus ( 06262 CLLRPStatus * pValue); 06263 06264 06265 }; 06266 06267 06299 class CGET_REPORT : public CMessage 06300 { 06301 public: 06302 CGET_REPORT (void); 06303 ~CGET_REPORT (void); 06304 06307 06308 static const CFieldDescriptor * const 06309 s_apFieldDescriptorTable[]; 06310 06311 static const CTypeDescriptor 06312 s_typeDescriptor; 06313 06314 void 06315 decodeFields ( 06316 CDecoderStream * pDecoderStream); 06317 06318 void 06319 assimilateSubParameters ( 06320 CErrorDetails * pError); 06321 06322 void 06323 encode ( 06324 CEncoderStream * pEncoderStream) const; 06325 06326 06327 06328 static CElement * 06329 s_construct (void); 06330 06331 static void 06332 s_decodeFields ( 06333 CDecoderStream * pDecoderStream, 06334 CElement * pElement); 06336 06337 06338 06339 }; 06340 06341 06374 class CRO_ACCESS_REPORT : public CMessage 06375 { 06376 public: 06377 CRO_ACCESS_REPORT (void); 06378 ~CRO_ACCESS_REPORT (void); 06379 06382 06383 static const CFieldDescriptor * const 06384 s_apFieldDescriptorTable[]; 06385 06386 static const CTypeDescriptor 06387 s_typeDescriptor; 06388 06389 void 06390 decodeFields ( 06391 CDecoderStream * pDecoderStream); 06392 06393 void 06394 assimilateSubParameters ( 06395 CErrorDetails * pError); 06396 06397 void 06398 encode ( 06399 CEncoderStream * pEncoderStream) const; 06400 06401 06402 06403 static CElement * 06404 s_construct (void); 06405 06406 static void 06407 s_decodeFields ( 06408 CDecoderStream * pDecoderStream, 06409 CElement * pElement); 06411 06412 06413 06414 protected: 06415 std::list<CTagReportData *> m_listTagReportData; 06416 06417 public: 06419 inline std::list<CTagReportData *>::iterator 06420 beginTagReportData (void) 06421 { 06422 return m_listTagReportData.begin(); 06423 } 06424 06426 inline std::list<CTagReportData *>::iterator 06427 endTagReportData (void) 06428 { 06429 return m_listTagReportData.end(); 06430 } 06431 06433 inline void 06434 clearTagReportData (void) 06435 { 06436 clearSubParameterList ((tListOfParameters *) &m_listTagReportData); 06437 } 06438 06440 inline int 06441 countTagReportData (void) 06442 { 06443 return (int) (m_listTagReportData.size()); 06444 } 06445 06446 EResultCode 06448 addTagReportData ( 06449 CTagReportData * pValue); 06450 06451 06452 protected: 06453 std::list<CRFSurveyReportData *> m_listRFSurveyReportData; 06454 06455 public: 06457 inline std::list<CRFSurveyReportData *>::iterator 06458 beginRFSurveyReportData (void) 06459 { 06460 return m_listRFSurveyReportData.begin(); 06461 } 06462 06464 inline std::list<CRFSurveyReportData *>::iterator 06465 endRFSurveyReportData (void) 06466 { 06467 return m_listRFSurveyReportData.end(); 06468 } 06469 06471 inline void 06472 clearRFSurveyReportData (void) 06473 { 06474 clearSubParameterList ((tListOfParameters *) &m_listRFSurveyReportData); 06475 } 06476 06478 inline int 06479 countRFSurveyReportData (void) 06480 { 06481 return (int) (m_listRFSurveyReportData.size()); 06482 } 06483 06484 EResultCode 06486 addRFSurveyReportData ( 06487 CRFSurveyReportData * pValue); 06488 06489 06490 protected: 06491 std::list<CParameter *> m_listCustom; 06492 06493 public: 06495 inline std::list<CParameter *>::iterator 06496 beginCustom (void) 06497 { 06498 return m_listCustom.begin(); 06499 } 06500 06502 inline std::list<CParameter *>::iterator 06503 endCustom (void) 06504 { 06505 return m_listCustom.end(); 06506 } 06507 06509 inline void 06510 clearCustom (void) 06511 { 06512 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06513 } 06514 06516 inline int 06517 countCustom (void) 06518 { 06519 return (int) (m_listCustom.size()); 06520 } 06521 06522 EResultCode 06524 addCustom ( 06525 CParameter * pValue); 06526 06527 06528 }; 06529 06530 06560 class CKEEPALIVE : public CMessage 06561 { 06562 public: 06563 CKEEPALIVE (void); 06564 ~CKEEPALIVE (void); 06565 06568 06569 static const CFieldDescriptor * const 06570 s_apFieldDescriptorTable[]; 06571 06572 static const CTypeDescriptor 06573 s_typeDescriptor; 06574 06575 void 06576 decodeFields ( 06577 CDecoderStream * pDecoderStream); 06578 06579 void 06580 assimilateSubParameters ( 06581 CErrorDetails * pError); 06582 06583 void 06584 encode ( 06585 CEncoderStream * pEncoderStream) const; 06586 06587 06588 06589 static CElement * 06590 s_construct (void); 06591 06592 static void 06593 s_decodeFields ( 06594 CDecoderStream * pDecoderStream, 06595 CElement * pElement); 06597 06598 06599 06600 }; 06601 06602 06634 class CKEEPALIVE_ACK : public CMessage 06635 { 06636 public: 06637 CKEEPALIVE_ACK (void); 06638 ~CKEEPALIVE_ACK (void); 06639 06642 06643 static const CFieldDescriptor * const 06644 s_apFieldDescriptorTable[]; 06645 06646 static const CTypeDescriptor 06647 s_typeDescriptor; 06648 06649 void 06650 decodeFields ( 06651 CDecoderStream * pDecoderStream); 06652 06653 void 06654 assimilateSubParameters ( 06655 CErrorDetails * pError); 06656 06657 void 06658 encode ( 06659 CEncoderStream * pEncoderStream) const; 06660 06661 06662 06663 static CElement * 06664 s_construct (void); 06665 06666 static void 06667 s_decodeFields ( 06668 CDecoderStream * pDecoderStream, 06669 CElement * pElement); 06671 06672 06673 06674 }; 06675 06676 06707 class CREADER_EVENT_NOTIFICATION : public CMessage 06708 { 06709 public: 06710 CREADER_EVENT_NOTIFICATION (void); 06711 ~CREADER_EVENT_NOTIFICATION (void); 06712 06715 06716 static const CFieldDescriptor * const 06717 s_apFieldDescriptorTable[]; 06718 06719 static const CTypeDescriptor 06720 s_typeDescriptor; 06721 06722 void 06723 decodeFields ( 06724 CDecoderStream * pDecoderStream); 06725 06726 void 06727 assimilateSubParameters ( 06728 CErrorDetails * pError); 06729 06730 void 06731 encode ( 06732 CEncoderStream * pEncoderStream) const; 06733 06734 06735 06736 static CElement * 06737 s_construct (void); 06738 06739 static void 06740 s_decodeFields ( 06741 CDecoderStream * pDecoderStream, 06742 CElement * pElement); 06744 06745 06746 06747 protected: 06748 CReaderEventNotificationData * m_pReaderEventNotificationData; 06749 06750 public: 06752 inline CReaderEventNotificationData * 06753 getReaderEventNotificationData (void) 06754 { 06755 return m_pReaderEventNotificationData; 06756 } 06757 06759 EResultCode 06760 setReaderEventNotificationData ( 06761 CReaderEventNotificationData * pValue); 06762 06763 06764 }; 06765 06766 06796 class CENABLE_EVENTS_AND_REPORTS : public CMessage 06797 { 06798 public: 06799 CENABLE_EVENTS_AND_REPORTS (void); 06800 ~CENABLE_EVENTS_AND_REPORTS (void); 06801 06804 06805 static const CFieldDescriptor * const 06806 s_apFieldDescriptorTable[]; 06807 06808 static const CTypeDescriptor 06809 s_typeDescriptor; 06810 06811 void 06812 decodeFields ( 06813 CDecoderStream * pDecoderStream); 06814 06815 void 06816 assimilateSubParameters ( 06817 CErrorDetails * pError); 06818 06819 void 06820 encode ( 06821 CEncoderStream * pEncoderStream) const; 06822 06823 06824 06825 static CElement * 06826 s_construct (void); 06827 06828 static void 06829 s_decodeFields ( 06830 CDecoderStream * pDecoderStream, 06831 CElement * pElement); 06833 06834 06835 06836 }; 06837 06838 06897 class CERROR_MESSAGE : public CMessage 06898 { 06899 public: 06900 CERROR_MESSAGE (void); 06901 ~CERROR_MESSAGE (void); 06902 06905 06906 static const CFieldDescriptor * const 06907 s_apFieldDescriptorTable[]; 06908 06909 static const CTypeDescriptor 06910 s_typeDescriptor; 06911 06912 void 06913 decodeFields ( 06914 CDecoderStream * pDecoderStream); 06915 06916 void 06917 assimilateSubParameters ( 06918 CErrorDetails * pError); 06919 06920 void 06921 encode ( 06922 CEncoderStream * pEncoderStream) const; 06923 06924 06925 06926 static CElement * 06927 s_construct (void); 06928 06929 static void 06930 s_decodeFields ( 06931 CDecoderStream * pDecoderStream, 06932 CElement * pElement); 06934 06935 06936 06937 protected: 06938 CLLRPStatus * m_pLLRPStatus; 06939 06940 public: 06942 inline CLLRPStatus * 06943 getLLRPStatus (void) 06944 { 06945 return m_pLLRPStatus; 06946 } 06947 06949 EResultCode 06950 setLLRPStatus ( 06951 CLLRPStatus * pValue); 06952 06953 06954 }; 06955 06956 06964 06999 class CUTCTimestamp : public CParameter 07000 { 07001 public: 07002 CUTCTimestamp (void); 07003 ~CUTCTimestamp (void); 07004 07007 07008 static const CFieldDescriptor * const 07009 s_apFieldDescriptorTable[]; 07010 07011 static const CTypeDescriptor 07012 s_typeDescriptor; 07013 07014 void 07015 decodeFields ( 07016 CDecoderStream * pDecoderStream); 07017 07018 void 07019 assimilateSubParameters ( 07020 CErrorDetails * pError); 07021 07022 void 07023 encode ( 07024 CEncoderStream * pEncoderStream) const; 07025 07026 07027 07028 static CElement * 07029 s_construct (void); 07030 07031 static void 07032 s_decodeFields ( 07033 CDecoderStream * pDecoderStream, 07034 CElement * pElement); 07036 07037 07038 protected: 07039 llrp_u64_t m_Microseconds; 07040 07043 public: 07044 static const CFieldDescriptor 07045 s_fdMicroseconds; 07047 07049 inline llrp_u64_t 07050 getMicroseconds (void) 07051 { 07052 return m_Microseconds; 07053 } 07054 07056 inline void 07057 setMicroseconds ( 07058 llrp_u64_t value) 07059 { 07060 m_Microseconds = value; 07061 } 07062 07063 07064 07065 }; 07066 07067 07102 class CUptime : public CParameter 07103 { 07104 public: 07105 CUptime (void); 07106 ~CUptime (void); 07107 07110 07111 static const CFieldDescriptor * const 07112 s_apFieldDescriptorTable[]; 07113 07114 static const CTypeDescriptor 07115 s_typeDescriptor; 07116 07117 void 07118 decodeFields ( 07119 CDecoderStream * pDecoderStream); 07120 07121 void 07122 assimilateSubParameters ( 07123 CErrorDetails * pError); 07124 07125 void 07126 encode ( 07127 CEncoderStream * pEncoderStream) const; 07128 07129 07130 07131 static CElement * 07132 s_construct (void); 07133 07134 static void 07135 s_decodeFields ( 07136 CDecoderStream * pDecoderStream, 07137 CElement * pElement); 07139 07140 07141 protected: 07142 llrp_u64_t m_Microseconds; 07143 07146 public: 07147 static const CFieldDescriptor 07148 s_fdMicroseconds; 07150 07152 inline llrp_u64_t 07153 getMicroseconds (void) 07154 { 07155 return m_Microseconds; 07156 } 07157 07159 inline void 07160 setMicroseconds ( 07161 llrp_u64_t value) 07162 { 07163 m_Microseconds = value; 07164 } 07165 07166 07167 07168 }; 07169 07170 07214 class CCustom : public CParameter 07215 { 07216 public: 07217 CCustom (void); 07218 ~CCustom (void); 07219 07222 07223 static const CFieldDescriptor * const 07224 s_apFieldDescriptorTable[]; 07225 07226 static const CTypeDescriptor 07227 s_typeDescriptor; 07228 07229 void 07230 decodeFields ( 07231 CDecoderStream * pDecoderStream); 07232 07233 void 07234 assimilateSubParameters ( 07235 CErrorDetails * pError); 07236 07237 void 07238 encode ( 07239 CEncoderStream * pEncoderStream) const; 07240 07241 07242 07243 static CElement * 07244 s_construct (void); 07245 07246 static void 07247 s_decodeFields ( 07248 CDecoderStream * pDecoderStream, 07249 CElement * pElement); 07251 07252 07253 protected: 07254 llrp_u32_t m_VendorIdentifier; 07255 07258 public: 07259 static const CFieldDescriptor 07260 s_fdVendorIdentifier; 07262 07264 inline llrp_u32_t 07265 getVendorIdentifier (void) 07266 { 07267 return m_VendorIdentifier; 07268 } 07269 07271 inline void 07272 setVendorIdentifier ( 07273 llrp_u32_t value) 07274 { 07275 m_VendorIdentifier = value; 07276 } 07277 07278 07279 protected: 07280 llrp_u32_t m_ParameterSubtype; 07281 07284 public: 07285 static const CFieldDescriptor 07286 s_fdParameterSubtype; 07288 07290 inline llrp_u32_t 07291 getParameterSubtype (void) 07292 { 07293 return m_ParameterSubtype; 07294 } 07295 07297 inline void 07298 setParameterSubtype ( 07299 llrp_u32_t value) 07300 { 07301 m_ParameterSubtype = value; 07302 } 07303 07304 07305 protected: 07306 llrp_bytesToEnd_t m_Data; 07307 07310 public: 07311 static const CFieldDescriptor 07312 s_fdData; 07314 07316 inline llrp_bytesToEnd_t 07317 getData (void) 07318 { 07319 return m_Data; 07320 } 07321 07323 inline void 07324 setData ( 07325 llrp_bytesToEnd_t value) 07326 { 07327 m_Data = value; 07328 } 07329 07330 07331 07332 }; 07333 07334 07375 class CGeneralDeviceCapabilities : public CParameter 07376 { 07377 public: 07378 CGeneralDeviceCapabilities (void); 07379 ~CGeneralDeviceCapabilities (void); 07380 07383 07384 static const CFieldDescriptor * const 07385 s_apFieldDescriptorTable[]; 07386 07387 static const CTypeDescriptor 07388 s_typeDescriptor; 07389 07390 void 07391 decodeFields ( 07392 CDecoderStream * pDecoderStream); 07393 07394 void 07395 assimilateSubParameters ( 07396 CErrorDetails * pError); 07397 07398 void 07399 encode ( 07400 CEncoderStream * pEncoderStream) const; 07401 07402 07403 07404 static CElement * 07405 s_construct (void); 07406 07407 static void 07408 s_decodeFields ( 07409 CDecoderStream * pDecoderStream, 07410 CElement * pElement); 07412 07413 07414 protected: 07415 llrp_u16_t m_MaxNumberOfAntennaSupported; 07416 07419 public: 07420 static const CFieldDescriptor 07421 s_fdMaxNumberOfAntennaSupported; 07423 07425 inline llrp_u16_t 07426 getMaxNumberOfAntennaSupported (void) 07427 { 07428 return m_MaxNumberOfAntennaSupported; 07429 } 07430 07432 inline void 07433 setMaxNumberOfAntennaSupported ( 07434 llrp_u16_t value) 07435 { 07436 m_MaxNumberOfAntennaSupported = value; 07437 } 07438 07439 07440 protected: 07441 llrp_u1_t m_CanSetAntennaProperties; 07442 07445 public: 07446 static const CFieldDescriptor 07447 s_fdCanSetAntennaProperties; 07449 07451 inline llrp_u1_t 07452 getCanSetAntennaProperties (void) 07453 { 07454 return m_CanSetAntennaProperties; 07455 } 07456 07458 inline void 07459 setCanSetAntennaProperties ( 07460 llrp_u1_t value) 07461 { 07462 m_CanSetAntennaProperties = value; 07463 } 07464 07465 07466 protected: 07467 llrp_u1_t m_HasUTCClockCapability; 07468 07471 public: 07472 static const CFieldDescriptor 07473 s_fdHasUTCClockCapability; 07475 07477 inline llrp_u1_t 07478 getHasUTCClockCapability (void) 07479 { 07480 return m_HasUTCClockCapability; 07481 } 07482 07484 inline void 07485 setHasUTCClockCapability ( 07486 llrp_u1_t value) 07487 { 07488 m_HasUTCClockCapability = value; 07489 } 07490 07491 07492 protected: 07493 llrp_u32_t m_DeviceManufacturerName; 07494 07497 public: 07498 static const CFieldDescriptor 07499 s_fdDeviceManufacturerName; 07501 07503 inline llrp_u32_t 07504 getDeviceManufacturerName (void) 07505 { 07506 return m_DeviceManufacturerName; 07507 } 07508 07510 inline void 07511 setDeviceManufacturerName ( 07512 llrp_u32_t value) 07513 { 07514 m_DeviceManufacturerName = value; 07515 } 07516 07517 07518 protected: 07519 llrp_u32_t m_ModelName; 07520 07523 public: 07524 static const CFieldDescriptor 07525 s_fdModelName; 07527 07529 inline llrp_u32_t 07530 getModelName (void) 07531 { 07532 return m_ModelName; 07533 } 07534 07536 inline void 07537 setModelName ( 07538 llrp_u32_t value) 07539 { 07540 m_ModelName = value; 07541 } 07542 07543 07544 protected: 07545 llrp_utf8v_t m_ReaderFirmwareVersion; 07546 07549 public: 07550 static const CFieldDescriptor 07551 s_fdReaderFirmwareVersion; 07553 07555 inline llrp_utf8v_t 07556 getReaderFirmwareVersion (void) 07557 { 07558 return m_ReaderFirmwareVersion; 07559 } 07560 07562 inline void 07563 setReaderFirmwareVersion ( 07564 llrp_utf8v_t value) 07565 { 07566 m_ReaderFirmwareVersion = value; 07567 } 07568 07569 07570 07571 protected: 07572 std::list<CReceiveSensitivityTableEntry *> m_listReceiveSensitivityTableEntry; 07573 07574 public: 07576 inline std::list<CReceiveSensitivityTableEntry *>::iterator 07577 beginReceiveSensitivityTableEntry (void) 07578 { 07579 return m_listReceiveSensitivityTableEntry.begin(); 07580 } 07581 07583 inline std::list<CReceiveSensitivityTableEntry *>::iterator 07584 endReceiveSensitivityTableEntry (void) 07585 { 07586 return m_listReceiveSensitivityTableEntry.end(); 07587 } 07588 07590 inline void 07591 clearReceiveSensitivityTableEntry (void) 07592 { 07593 clearSubParameterList ((tListOfParameters *) &m_listReceiveSensitivityTableEntry); 07594 } 07595 07597 inline int 07598 countReceiveSensitivityTableEntry (void) 07599 { 07600 return (int) (m_listReceiveSensitivityTableEntry.size()); 07601 } 07602 07603 EResultCode 07605 addReceiveSensitivityTableEntry ( 07606 CReceiveSensitivityTableEntry * pValue); 07607 07608 07609 protected: 07610 std::list<CPerAntennaReceiveSensitivityRange *> m_listPerAntennaReceiveSensitivityRange; 07611 07612 public: 07614 inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator 07615 beginPerAntennaReceiveSensitivityRange (void) 07616 { 07617 return m_listPerAntennaReceiveSensitivityRange.begin(); 07618 } 07619 07621 inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator 07622 endPerAntennaReceiveSensitivityRange (void) 07623 { 07624 return m_listPerAntennaReceiveSensitivityRange.end(); 07625 } 07626 07628 inline void 07629 clearPerAntennaReceiveSensitivityRange (void) 07630 { 07631 clearSubParameterList ((tListOfParameters *) &m_listPerAntennaReceiveSensitivityRange); 07632 } 07633 07635 inline int 07636 countPerAntennaReceiveSensitivityRange (void) 07637 { 07638 return (int) (m_listPerAntennaReceiveSensitivityRange.size()); 07639 } 07640 07641 EResultCode 07643 addPerAntennaReceiveSensitivityRange ( 07644 CPerAntennaReceiveSensitivityRange * pValue); 07645 07646 07647 protected: 07648 CGPIOCapabilities * m_pGPIOCapabilities; 07649 07650 public: 07652 inline CGPIOCapabilities * 07653 getGPIOCapabilities (void) 07654 { 07655 return m_pGPIOCapabilities; 07656 } 07657 07659 EResultCode 07660 setGPIOCapabilities ( 07661 CGPIOCapabilities * pValue); 07662 07663 07664 protected: 07665 std::list<CPerAntennaAirProtocol *> m_listPerAntennaAirProtocol; 07666 07667 public: 07669 inline std::list<CPerAntennaAirProtocol *>::iterator 07670 beginPerAntennaAirProtocol (void) 07671 { 07672 return m_listPerAntennaAirProtocol.begin(); 07673 } 07674 07676 inline std::list<CPerAntennaAirProtocol *>::iterator 07677 endPerAntennaAirProtocol (void) 07678 { 07679 return m_listPerAntennaAirProtocol.end(); 07680 } 07681 07683 inline void 07684 clearPerAntennaAirProtocol (void) 07685 { 07686 clearSubParameterList ((tListOfParameters *) &m_listPerAntennaAirProtocol); 07687 } 07688 07690 inline int 07691 countPerAntennaAirProtocol (void) 07692 { 07693 return (int) (m_listPerAntennaAirProtocol.size()); 07694 } 07695 07696 EResultCode 07698 addPerAntennaAirProtocol ( 07699 CPerAntennaAirProtocol * pValue); 07700 07701 07702 }; 07703 07704 07739 class CReceiveSensitivityTableEntry : public CParameter 07740 { 07741 public: 07742 CReceiveSensitivityTableEntry (void); 07743 ~CReceiveSensitivityTableEntry (void); 07744 07747 07748 static const CFieldDescriptor * const 07749 s_apFieldDescriptorTable[]; 07750 07751 static const CTypeDescriptor 07752 s_typeDescriptor; 07753 07754 void 07755 decodeFields ( 07756 CDecoderStream * pDecoderStream); 07757 07758 void 07759 assimilateSubParameters ( 07760 CErrorDetails * pError); 07761 07762 void 07763 encode ( 07764 CEncoderStream * pEncoderStream) const; 07765 07766 07767 07768 static CElement * 07769 s_construct (void); 07770 07771 static void 07772 s_decodeFields ( 07773 CDecoderStream * pDecoderStream, 07774 CElement * pElement); 07776 07777 07778 protected: 07779 llrp_u16_t m_Index; 07780 07783 public: 07784 static const CFieldDescriptor 07785 s_fdIndex; 07787 07789 inline llrp_u16_t 07790 getIndex (void) 07791 { 07792 return m_Index; 07793 } 07794 07796 inline void 07797 setIndex ( 07798 llrp_u16_t value) 07799 { 07800 m_Index = value; 07801 } 07802 07803 07804 protected: 07805 llrp_s16_t m_ReceiveSensitivityValue; 07806 07809 public: 07810 static const CFieldDescriptor 07811 s_fdReceiveSensitivityValue; 07813 07815 inline llrp_s16_t 07816 getReceiveSensitivityValue (void) 07817 { 07818 return m_ReceiveSensitivityValue; 07819 } 07820 07822 inline void 07823 setReceiveSensitivityValue ( 07824 llrp_s16_t value) 07825 { 07826 m_ReceiveSensitivityValue = value; 07827 } 07828 07829 07830 07831 }; 07832 07833 07871 class CPerAntennaReceiveSensitivityRange : public CParameter 07872 { 07873 public: 07874 CPerAntennaReceiveSensitivityRange (void); 07875 ~CPerAntennaReceiveSensitivityRange (void); 07876 07879 07880 static const CFieldDescriptor * const 07881 s_apFieldDescriptorTable[]; 07882 07883 static const CTypeDescriptor 07884 s_typeDescriptor; 07885 07886 void 07887 decodeFields ( 07888 CDecoderStream * pDecoderStream); 07889 07890 void 07891 assimilateSubParameters ( 07892 CErrorDetails * pError); 07893 07894 void 07895 encode ( 07896 CEncoderStream * pEncoderStream) const; 07897 07898 07899 07900 static CElement * 07901 s_construct (void); 07902 07903 static void 07904 s_decodeFields ( 07905 CDecoderStream * pDecoderStream, 07906 CElement * pElement); 07908 07909 07910 protected: 07911 llrp_u16_t m_AntennaID; 07912 07915 public: 07916 static const CFieldDescriptor 07917 s_fdAntennaID; 07919 07921 inline llrp_u16_t 07922 getAntennaID (void) 07923 { 07924 return m_AntennaID; 07925 } 07926 07928 inline void 07929 setAntennaID ( 07930 llrp_u16_t value) 07931 { 07932 m_AntennaID = value; 07933 } 07934 07935 07936 protected: 07937 llrp_u16_t m_ReceiveSensitivityIndexMin; 07938 07941 public: 07942 static const CFieldDescriptor 07943 s_fdReceiveSensitivityIndexMin; 07945 07947 inline llrp_u16_t 07948 getReceiveSensitivityIndexMin (void) 07949 { 07950 return m_ReceiveSensitivityIndexMin; 07951 } 07952 07954 inline void 07955 setReceiveSensitivityIndexMin ( 07956 llrp_u16_t value) 07957 { 07958 m_ReceiveSensitivityIndexMin = value; 07959 } 07960 07961 07962 protected: 07963 llrp_u16_t m_ReceiveSensitivityIndexMax; 07964 07967 public: 07968 static const CFieldDescriptor 07969 s_fdReceiveSensitivityIndexMax; 07971 07973 inline llrp_u16_t 07974 getReceiveSensitivityIndexMax (void) 07975 { 07976 return m_ReceiveSensitivityIndexMax; 07977 } 07978 07980 inline void 07981 setReceiveSensitivityIndexMax ( 07982 llrp_u16_t value) 07983 { 07984 m_ReceiveSensitivityIndexMax = value; 07985 } 07986 07987 07988 07989 }; 07990 07991 08023 class CPerAntennaAirProtocol : public CParameter 08024 { 08025 public: 08026 CPerAntennaAirProtocol (void); 08027 ~CPerAntennaAirProtocol (void); 08028 08031 08032 static const CFieldDescriptor * const 08033 s_apFieldDescriptorTable[]; 08034 08035 static const CTypeDescriptor 08036 s_typeDescriptor; 08037 08038 void 08039 decodeFields ( 08040 CDecoderStream * pDecoderStream); 08041 08042 void 08043 assimilateSubParameters ( 08044 CErrorDetails * pError); 08045 08046 void 08047 encode ( 08048 CEncoderStream * pEncoderStream) const; 08049 08050 08051 08052 static CElement * 08053 s_construct (void); 08054 08055 static void 08056 s_decodeFields ( 08057 CDecoderStream * pDecoderStream, 08058 CElement * pElement); 08060 08061 08062 protected: 08063 llrp_u16_t m_AntennaID; 08064 08067 public: 08068 static const CFieldDescriptor 08069 s_fdAntennaID; 08071 08073 inline llrp_u16_t 08074 getAntennaID (void) 08075 { 08076 return m_AntennaID; 08077 } 08078 08080 inline void 08081 setAntennaID ( 08082 llrp_u16_t value) 08083 { 08084 m_AntennaID = value; 08085 } 08086 08087 08088 protected: 08089 llrp_u8v_t m_ProtocolID; 08090 08093 public: 08094 static const CFieldDescriptor 08095 s_fdProtocolID; 08097 08099 inline llrp_u8v_t 08100 getProtocolID (void) 08101 { 08102 return m_ProtocolID; 08103 } 08104 08106 inline void 08107 setProtocolID ( 08108 llrp_u8v_t value) 08109 { 08110 m_ProtocolID = value; 08111 } 08112 08113 08114 08115 }; 08116 08117 08149 class CGPIOCapabilities : public CParameter 08150 { 08151 public: 08152 CGPIOCapabilities (void); 08153 ~CGPIOCapabilities (void); 08154 08157 08158 static const CFieldDescriptor * const 08159 s_apFieldDescriptorTable[]; 08160 08161 static const CTypeDescriptor 08162 s_typeDescriptor; 08163 08164 void 08165 decodeFields ( 08166 CDecoderStream * pDecoderStream); 08167 08168 void 08169 assimilateSubParameters ( 08170 CErrorDetails * pError); 08171 08172 void 08173 encode ( 08174 CEncoderStream * pEncoderStream) const; 08175 08176 08177 08178 static CElement * 08179 s_construct (void); 08180 08181 static void 08182 s_decodeFields ( 08183 CDecoderStream * pDecoderStream, 08184 CElement * pElement); 08186 08187 08188 protected: 08189 llrp_u16_t m_NumGPIs; 08190 08193 public: 08194 static const CFieldDescriptor 08195 s_fdNumGPIs; 08197 08199 inline llrp_u16_t 08200 getNumGPIs (void) 08201 { 08202 return m_NumGPIs; 08203 } 08204 08206 inline void 08207 setNumGPIs ( 08208 llrp_u16_t value) 08209 { 08210 m_NumGPIs = value; 08211 } 08212 08213 08214 protected: 08215 llrp_u16_t m_NumGPOs; 08216 08219 public: 08220 static const CFieldDescriptor 08221 s_fdNumGPOs; 08223 08225 inline llrp_u16_t 08226 getNumGPOs (void) 08227 { 08228 return m_NumGPOs; 08229 } 08230 08232 inline void 08233 setNumGPOs ( 08234 llrp_u16_t value) 08235 { 08236 m_NumGPOs = value; 08237 } 08238 08239 08240 08241 }; 08242 08243 08303 class CLLRPCapabilities : public CParameter 08304 { 08305 public: 08306 CLLRPCapabilities (void); 08307 ~CLLRPCapabilities (void); 08308 08311 08312 static const CFieldDescriptor * const 08313 s_apFieldDescriptorTable[]; 08314 08315 static const CTypeDescriptor 08316 s_typeDescriptor; 08317 08318 void 08319 decodeFields ( 08320 CDecoderStream * pDecoderStream); 08321 08322 void 08323 assimilateSubParameters ( 08324 CErrorDetails * pError); 08325 08326 void 08327 encode ( 08328 CEncoderStream * pEncoderStream) const; 08329 08330 08331 08332 static CElement * 08333 s_construct (void); 08334 08335 static void 08336 s_decodeFields ( 08337 CDecoderStream * pDecoderStream, 08338 CElement * pElement); 08340 08341 08342 protected: 08343 llrp_u1_t m_CanDoRFSurvey; 08344 08347 public: 08348 static const CFieldDescriptor 08349 s_fdCanDoRFSurvey; 08351 08353 inline llrp_u1_t 08354 getCanDoRFSurvey (void) 08355 { 08356 return m_CanDoRFSurvey; 08357 } 08358 08360 inline void 08361 setCanDoRFSurvey ( 08362 llrp_u1_t value) 08363 { 08364 m_CanDoRFSurvey = value; 08365 } 08366 08367 08368 protected: 08369 llrp_u1_t m_CanReportBufferFillWarning; 08370 08373 public: 08374 static const CFieldDescriptor 08375 s_fdCanReportBufferFillWarning; 08377 08379 inline llrp_u1_t 08380 getCanReportBufferFillWarning (void) 08381 { 08382 return m_CanReportBufferFillWarning; 08383 } 08384 08386 inline void 08387 setCanReportBufferFillWarning ( 08388 llrp_u1_t value) 08389 { 08390 m_CanReportBufferFillWarning = value; 08391 } 08392 08393 08394 protected: 08395 llrp_u1_t m_SupportsClientRequestOpSpec; 08396 08399 public: 08400 static const CFieldDescriptor 08401 s_fdSupportsClientRequestOpSpec; 08403 08405 inline llrp_u1_t 08406 getSupportsClientRequestOpSpec (void) 08407 { 08408 return m_SupportsClientRequestOpSpec; 08409 } 08410 08412 inline void 08413 setSupportsClientRequestOpSpec ( 08414 llrp_u1_t value) 08415 { 08416 m_SupportsClientRequestOpSpec = value; 08417 } 08418 08419 08420 protected: 08421 llrp_u1_t m_CanDoTagInventoryStateAwareSingulation; 08422 08425 public: 08426 static const CFieldDescriptor 08427 s_fdCanDoTagInventoryStateAwareSingulation; 08429 08431 inline llrp_u1_t 08432 getCanDoTagInventoryStateAwareSingulation (void) 08433 { 08434 return m_CanDoTagInventoryStateAwareSingulation; 08435 } 08436 08438 inline void 08439 setCanDoTagInventoryStateAwareSingulation ( 08440 llrp_u1_t value) 08441 { 08442 m_CanDoTagInventoryStateAwareSingulation = value; 08443 } 08444 08445 08446 protected: 08447 llrp_u1_t m_SupportsEventAndReportHolding; 08448 08451 public: 08452 static const CFieldDescriptor 08453 s_fdSupportsEventAndReportHolding; 08455 08457 inline llrp_u1_t 08458 getSupportsEventAndReportHolding (void) 08459 { 08460 return m_SupportsEventAndReportHolding; 08461 } 08462 08464 inline void 08465 setSupportsEventAndReportHolding ( 08466 llrp_u1_t value) 08467 { 08468 m_SupportsEventAndReportHolding = value; 08469 } 08470 08471 08472 protected: 08473 llrp_u8_t m_MaxNumPriorityLevelsSupported; 08474 08477 public: 08478 static const CFieldDescriptor 08479 s_fdMaxNumPriorityLevelsSupported; 08481 08483 inline llrp_u8_t 08484 getMaxNumPriorityLevelsSupported (void) 08485 { 08486 return m_MaxNumPriorityLevelsSupported; 08487 } 08488 08490 inline void 08491 setMaxNumPriorityLevelsSupported ( 08492 llrp_u8_t value) 08493 { 08494 m_MaxNumPriorityLevelsSupported = value; 08495 } 08496 08497 08498 protected: 08499 llrp_u16_t m_ClientRequestOpSpecTimeout; 08500 08503 public: 08504 static const CFieldDescriptor 08505 s_fdClientRequestOpSpecTimeout; 08507 08509 inline llrp_u16_t 08510 getClientRequestOpSpecTimeout (void) 08511 { 08512 return m_ClientRequestOpSpecTimeout; 08513 } 08514 08516 inline void 08517 setClientRequestOpSpecTimeout ( 08518 llrp_u16_t value) 08519 { 08520 m_ClientRequestOpSpecTimeout = value; 08521 } 08522 08523 08524 protected: 08525 llrp_u32_t m_MaxNumROSpecs; 08526 08529 public: 08530 static const CFieldDescriptor 08531 s_fdMaxNumROSpecs; 08533 08535 inline llrp_u32_t 08536 getMaxNumROSpecs (void) 08537 { 08538 return m_MaxNumROSpecs; 08539 } 08540 08542 inline void 08543 setMaxNumROSpecs ( 08544 llrp_u32_t value) 08545 { 08546 m_MaxNumROSpecs = value; 08547 } 08548 08549 08550 protected: 08551 llrp_u32_t m_MaxNumSpecsPerROSpec; 08552 08555 public: 08556 static const CFieldDescriptor 08557 s_fdMaxNumSpecsPerROSpec; 08559 08561 inline llrp_u32_t 08562 getMaxNumSpecsPerROSpec (void) 08563 { 08564 return m_MaxNumSpecsPerROSpec; 08565 } 08566 08568 inline void 08569 setMaxNumSpecsPerROSpec ( 08570 llrp_u32_t value) 08571 { 08572 m_MaxNumSpecsPerROSpec = value; 08573 } 08574 08575 08576 protected: 08577 llrp_u32_t m_MaxNumInventoryParameterSpecsPerAISpec; 08578 08581 public: 08582 static const CFieldDescriptor 08583 s_fdMaxNumInventoryParameterSpecsPerAISpec; 08585 08587 inline llrp_u32_t 08588 getMaxNumInventoryParameterSpecsPerAISpec (void) 08589 { 08590 return m_MaxNumInventoryParameterSpecsPerAISpec; 08591 } 08592 08594 inline void 08595 setMaxNumInventoryParameterSpecsPerAISpec ( 08596 llrp_u32_t value) 08597 { 08598 m_MaxNumInventoryParameterSpecsPerAISpec = value; 08599 } 08600 08601 08602 protected: 08603 llrp_u32_t m_MaxNumAccessSpecs; 08604 08607 public: 08608 static const CFieldDescriptor 08609 s_fdMaxNumAccessSpecs; 08611 08613 inline llrp_u32_t 08614 getMaxNumAccessSpecs (void) 08615 { 08616 return m_MaxNumAccessSpecs; 08617 } 08618 08620 inline void 08621 setMaxNumAccessSpecs ( 08622 llrp_u32_t value) 08623 { 08624 m_MaxNumAccessSpecs = value; 08625 } 08626 08627 08628 protected: 08629 llrp_u32_t m_MaxNumOpSpecsPerAccessSpec; 08630 08633 public: 08634 static const CFieldDescriptor 08635 s_fdMaxNumOpSpecsPerAccessSpec; 08637 08639 inline llrp_u32_t 08640 getMaxNumOpSpecsPerAccessSpec (void) 08641 { 08642 return m_MaxNumOpSpecsPerAccessSpec; 08643 } 08644 08646 inline void 08647 setMaxNumOpSpecsPerAccessSpec ( 08648 llrp_u32_t value) 08649 { 08650 m_MaxNumOpSpecsPerAccessSpec = value; 08651 } 08652 08653 08654 08655 }; 08656 08657 08694 class CRegulatoryCapabilities : public CParameter 08695 { 08696 public: 08697 CRegulatoryCapabilities (void); 08698 ~CRegulatoryCapabilities (void); 08699 08702 08703 static const CFieldDescriptor * const 08704 s_apFieldDescriptorTable[]; 08705 08706 static const CTypeDescriptor 08707 s_typeDescriptor; 08708 08709 void 08710 decodeFields ( 08711 CDecoderStream * pDecoderStream); 08712 08713 void 08714 assimilateSubParameters ( 08715 CErrorDetails * pError); 08716 08717 void 08718 encode ( 08719 CEncoderStream * pEncoderStream) const; 08720 08721 08722 08723 static CElement * 08724 s_construct (void); 08725 08726 static void 08727 s_decodeFields ( 08728 CDecoderStream * pDecoderStream, 08729 CElement * pElement); 08731 08732 08733 protected: 08734 llrp_u16_t m_CountryCode; 08735 08738 public: 08739 static const CFieldDescriptor 08740 s_fdCountryCode; 08742 08744 inline llrp_u16_t 08745 getCountryCode (void) 08746 { 08747 return m_CountryCode; 08748 } 08749 08751 inline void 08752 setCountryCode ( 08753 llrp_u16_t value) 08754 { 08755 m_CountryCode = value; 08756 } 08757 08758 08759 protected: 08760 ECommunicationsStandard m_eCommunicationsStandard; 08761 08764 public: 08765 static const CFieldDescriptor 08766 s_fdCommunicationsStandard; 08768 08770 inline ECommunicationsStandard 08771 getCommunicationsStandard (void) 08772 { 08773 return m_eCommunicationsStandard; 08774 } 08775 08777 inline void 08778 setCommunicationsStandard ( 08779 ECommunicationsStandard value) 08780 { 08781 m_eCommunicationsStandard = value; 08782 } 08783 08784 08785 08786 protected: 08787 CUHFBandCapabilities * m_pUHFBandCapabilities; 08788 08789 public: 08791 inline CUHFBandCapabilities * 08792 getUHFBandCapabilities (void) 08793 { 08794 return m_pUHFBandCapabilities; 08795 } 08796 08798 EResultCode 08799 setUHFBandCapabilities ( 08800 CUHFBandCapabilities * pValue); 08801 08802 08803 protected: 08804 std::list<CParameter *> m_listCustom; 08805 08806 public: 08808 inline std::list<CParameter *>::iterator 08809 beginCustom (void) 08810 { 08811 return m_listCustom.begin(); 08812 } 08813 08815 inline std::list<CParameter *>::iterator 08816 endCustom (void) 08817 { 08818 return m_listCustom.end(); 08819 } 08820 08822 inline void 08823 clearCustom (void) 08824 { 08825 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08826 } 08827 08829 inline int 08830 countCustom (void) 08831 { 08832 return (int) (m_listCustom.size()); 08833 } 08834 08835 EResultCode 08837 addCustom ( 08838 CParameter * pValue); 08839 08840 08841 }; 08842 08843 08876 class CUHFBandCapabilities : public CParameter 08877 { 08878 public: 08879 CUHFBandCapabilities (void); 08880 ~CUHFBandCapabilities (void); 08881 08884 08885 static const CFieldDescriptor * const 08886 s_apFieldDescriptorTable[]; 08887 08888 static const CTypeDescriptor 08889 s_typeDescriptor; 08890 08891 void 08892 decodeFields ( 08893 CDecoderStream * pDecoderStream); 08894 08895 void 08896 assimilateSubParameters ( 08897 CErrorDetails * pError); 08898 08899 void 08900 encode ( 08901 CEncoderStream * pEncoderStream) const; 08902 08903 08904 08905 static CElement * 08906 s_construct (void); 08907 08908 static void 08909 s_decodeFields ( 08910 CDecoderStream * pDecoderStream, 08911 CElement * pElement); 08913 08914 08915 08916 protected: 08917 std::list<CTransmitPowerLevelTableEntry *> m_listTransmitPowerLevelTableEntry; 08918 08919 public: 08921 inline std::list<CTransmitPowerLevelTableEntry *>::iterator 08922 beginTransmitPowerLevelTableEntry (void) 08923 { 08924 return m_listTransmitPowerLevelTableEntry.begin(); 08925 } 08926 08928 inline std::list<CTransmitPowerLevelTableEntry *>::iterator 08929 endTransmitPowerLevelTableEntry (void) 08930 { 08931 return m_listTransmitPowerLevelTableEntry.end(); 08932 } 08933 08935 inline void 08936 clearTransmitPowerLevelTableEntry (void) 08937 { 08938 clearSubParameterList ((tListOfParameters *) &m_listTransmitPowerLevelTableEntry); 08939 } 08940 08942 inline int 08943 countTransmitPowerLevelTableEntry (void) 08944 { 08945 return (int) (m_listTransmitPowerLevelTableEntry.size()); 08946 } 08947 08948 EResultCode 08950 addTransmitPowerLevelTableEntry ( 08951 CTransmitPowerLevelTableEntry * pValue); 08952 08953 08954 protected: 08955 CFrequencyInformation * m_pFrequencyInformation; 08956 08957 public: 08959 inline CFrequencyInformation * 08960 getFrequencyInformation (void) 08961 { 08962 return m_pFrequencyInformation; 08963 } 08964 08966 EResultCode 08967 setFrequencyInformation ( 08968 CFrequencyInformation * pValue); 08969 08970 08971 protected: 08972 std::list<CParameter *> m_listAirProtocolUHFRFModeTable; 08973 08974 public: 08976 inline std::list<CParameter *>::iterator 08977 beginAirProtocolUHFRFModeTable (void) 08978 { 08979 return m_listAirProtocolUHFRFModeTable.begin(); 08980 } 08981 08983 inline std::list<CParameter *>::iterator 08984 endAirProtocolUHFRFModeTable (void) 08985 { 08986 return m_listAirProtocolUHFRFModeTable.end(); 08987 } 08988 08990 inline void 08991 clearAirProtocolUHFRFModeTable (void) 08992 { 08993 clearSubParameterList ((tListOfParameters *) &m_listAirProtocolUHFRFModeTable); 08994 } 08995 08997 inline int 08998 countAirProtocolUHFRFModeTable (void) 08999 { 09000 return (int) (m_listAirProtocolUHFRFModeTable.size()); 09001 } 09002 09003 EResultCode 09005 addAirProtocolUHFRFModeTable ( 09006 CParameter * pValue); 09007 09008 09009 }; 09010 09011 09043 class CTransmitPowerLevelTableEntry : public CParameter 09044 { 09045 public: 09046 CTransmitPowerLevelTableEntry (void); 09047 ~CTransmitPowerLevelTableEntry (void); 09048 09051 09052 static const CFieldDescriptor * const 09053 s_apFieldDescriptorTable[]; 09054 09055 static const CTypeDescriptor 09056 s_typeDescriptor; 09057 09058 void 09059 decodeFields ( 09060 CDecoderStream * pDecoderStream); 09061 09062 void 09063 assimilateSubParameters ( 09064 CErrorDetails * pError); 09065 09066 void 09067 encode ( 09068 CEncoderStream * pEncoderStream) const; 09069 09070 09071 09072 static CElement * 09073 s_construct (void); 09074 09075 static void 09076 s_decodeFields ( 09077 CDecoderStream * pDecoderStream, 09078 CElement * pElement); 09080 09081 09082 protected: 09083 llrp_u16_t m_Index; 09084 09087 public: 09088 static const CFieldDescriptor 09089 s_fdIndex; 09091 09093 inline llrp_u16_t 09094 getIndex (void) 09095 { 09096 return m_Index; 09097 } 09098 09100 inline void 09101 setIndex ( 09102 llrp_u16_t value) 09103 { 09104 m_Index = value; 09105 } 09106 09107 09108 protected: 09109 llrp_s16_t m_TransmitPowerValue; 09110 09113 public: 09114 static const CFieldDescriptor 09115 s_fdTransmitPowerValue; 09117 09119 inline llrp_s16_t 09120 getTransmitPowerValue (void) 09121 { 09122 return m_TransmitPowerValue; 09123 } 09124 09126 inline void 09127 setTransmitPowerValue ( 09128 llrp_s16_t value) 09129 { 09130 m_TransmitPowerValue = value; 09131 } 09132 09133 09134 09135 }; 09136 09137 09171 class CFrequencyInformation : public CParameter 09172 { 09173 public: 09174 CFrequencyInformation (void); 09175 ~CFrequencyInformation (void); 09176 09179 09180 static const CFieldDescriptor * const 09181 s_apFieldDescriptorTable[]; 09182 09183 static const CTypeDescriptor 09184 s_typeDescriptor; 09185 09186 void 09187 decodeFields ( 09188 CDecoderStream * pDecoderStream); 09189 09190 void 09191 assimilateSubParameters ( 09192 CErrorDetails * pError); 09193 09194 void 09195 encode ( 09196 CEncoderStream * pEncoderStream) const; 09197 09198 09199 09200 static CElement * 09201 s_construct (void); 09202 09203 static void 09204 s_decodeFields ( 09205 CDecoderStream * pDecoderStream, 09206 CElement * pElement); 09208 09209 09210 protected: 09211 llrp_u1_t m_Hopping; 09212 09215 public: 09216 static const CFieldDescriptor 09217 s_fdHopping; 09219 09221 inline llrp_u1_t 09222 getHopping (void) 09223 { 09224 return m_Hopping; 09225 } 09226 09228 inline void 09229 setHopping ( 09230 llrp_u1_t value) 09231 { 09232 m_Hopping = value; 09233 } 09234 09235 09236 09237 protected: 09238 std::list<CFrequencyHopTable *> m_listFrequencyHopTable; 09239 09240 public: 09242 inline std::list<CFrequencyHopTable *>::iterator 09243 beginFrequencyHopTable (void) 09244 { 09245 return m_listFrequencyHopTable.begin(); 09246 } 09247 09249 inline std::list<CFrequencyHopTable *>::iterator 09250 endFrequencyHopTable (void) 09251 { 09252 return m_listFrequencyHopTable.end(); 09253 } 09254 09256 inline void 09257 clearFrequencyHopTable (void) 09258 { 09259 clearSubParameterList ((tListOfParameters *) &m_listFrequencyHopTable); 09260 } 09261 09263 inline int 09264 countFrequencyHopTable (void) 09265 { 09266 return (int) (m_listFrequencyHopTable.size()); 09267 } 09268 09269 EResultCode 09271 addFrequencyHopTable ( 09272 CFrequencyHopTable * pValue); 09273 09274 09275 protected: 09276 CFixedFrequencyTable * m_pFixedFrequencyTable; 09277 09278 public: 09280 inline CFixedFrequencyTable * 09281 getFixedFrequencyTable (void) 09282 { 09283 return m_pFixedFrequencyTable; 09284 } 09285 09287 EResultCode 09288 setFixedFrequencyTable ( 09289 CFixedFrequencyTable * pValue); 09290 09291 09292 }; 09293 09294 09341 class CFrequencyHopTable : public CParameter 09342 { 09343 public: 09344 CFrequencyHopTable (void); 09345 ~CFrequencyHopTable (void); 09346 09349 09350 static const CFieldDescriptor * const 09351 s_apFieldDescriptorTable[]; 09352 09353 static const CTypeDescriptor 09354 s_typeDescriptor; 09355 09356 void 09357 decodeFields ( 09358 CDecoderStream * pDecoderStream); 09359 09360 void 09361 assimilateSubParameters ( 09362 CErrorDetails * pError); 09363 09364 void 09365 encode ( 09366 CEncoderStream * pEncoderStream) const; 09367 09368 09369 09370 static CElement * 09371 s_construct (void); 09372 09373 static void 09374 s_decodeFields ( 09375 CDecoderStream * pDecoderStream, 09376 CElement * pElement); 09378 09379 09380 protected: 09381 llrp_u8_t m_HopTableID; 09382 09385 public: 09386 static const CFieldDescriptor 09387 s_fdHopTableID; 09389 09391 inline llrp_u8_t 09392 getHopTableID (void) 09393 { 09394 return m_HopTableID; 09395 } 09396 09398 inline void 09399 setHopTableID ( 09400 llrp_u8_t value) 09401 { 09402 m_HopTableID = value; 09403 } 09404 09405 09406 protected: 09407 llrp_u32v_t m_Frequency; 09408 09411 public: 09412 static const CFieldDescriptor 09413 s_fdFrequency; 09415 09417 inline llrp_u32v_t 09418 getFrequency (void) 09419 { 09420 return m_Frequency; 09421 } 09422 09424 inline void 09425 setFrequency ( 09426 llrp_u32v_t value) 09427 { 09428 m_Frequency = value; 09429 } 09430 09431 09432 09433 }; 09434 09435 09466 class CFixedFrequencyTable : public CParameter 09467 { 09468 public: 09469 CFixedFrequencyTable (void); 09470 ~CFixedFrequencyTable (void); 09471 09474 09475 static const CFieldDescriptor * const 09476 s_apFieldDescriptorTable[]; 09477 09478 static const CTypeDescriptor 09479 s_typeDescriptor; 09480 09481 void 09482 decodeFields ( 09483 CDecoderStream * pDecoderStream); 09484 09485 void 09486 assimilateSubParameters ( 09487 CErrorDetails * pError); 09488 09489 void 09490 encode ( 09491 CEncoderStream * pEncoderStream) const; 09492 09493 09494 09495 static CElement * 09496 s_construct (void); 09497 09498 static void 09499 s_decodeFields ( 09500 CDecoderStream * pDecoderStream, 09501 CElement * pElement); 09503 09504 09505 protected: 09506 llrp_u32v_t m_Frequency; 09507 09510 public: 09511 static const CFieldDescriptor 09512 s_fdFrequency; 09514 09516 inline llrp_u32v_t 09517 getFrequency (void) 09518 { 09519 return m_Frequency; 09520 } 09521 09523 inline void 09524 setFrequency ( 09525 llrp_u32v_t value) 09526 { 09527 m_Frequency = value; 09528 } 09529 09530 09531 09532 }; 09533 09534 09570 class CROSpec : public CParameter 09571 { 09572 public: 09573 CROSpec (void); 09574 ~CROSpec (void); 09575 09578 09579 static const CFieldDescriptor * const 09580 s_apFieldDescriptorTable[]; 09581 09582 static const CTypeDescriptor 09583 s_typeDescriptor; 09584 09585 void 09586 decodeFields ( 09587 CDecoderStream * pDecoderStream); 09588 09589 void 09590 assimilateSubParameters ( 09591 CErrorDetails * pError); 09592 09593 void 09594 encode ( 09595 CEncoderStream * pEncoderStream) const; 09596 09597 09598 09599 static CElement * 09600 s_construct (void); 09601 09602 static void 09603 s_decodeFields ( 09604 CDecoderStream * pDecoderStream, 09605 CElement * pElement); 09607 09608 09609 protected: 09610 llrp_u32_t m_ROSpecID; 09611 09614 public: 09615 static const CFieldDescriptor 09616 s_fdROSpecID; 09618 09620 inline llrp_u32_t 09621 getROSpecID (void) 09622 { 09623 return m_ROSpecID; 09624 } 09625 09627 inline void 09628 setROSpecID ( 09629 llrp_u32_t value) 09630 { 09631 m_ROSpecID = value; 09632 } 09633 09634 09635 protected: 09636 llrp_u8_t m_Priority; 09637 09640 public: 09641 static const CFieldDescriptor 09642 s_fdPriority; 09644 09646 inline llrp_u8_t 09647 getPriority (void) 09648 { 09649 return m_Priority; 09650 } 09651 09653 inline void 09654 setPriority ( 09655 llrp_u8_t value) 09656 { 09657 m_Priority = value; 09658 } 09659 09660 09661 protected: 09662 EROSpecState m_eCurrentState; 09663 09666 public: 09667 static const CFieldDescriptor 09668 s_fdCurrentState; 09670 09672 inline EROSpecState 09673 getCurrentState (void) 09674 { 09675 return m_eCurrentState; 09676 } 09677 09679 inline void 09680 setCurrentState ( 09681 EROSpecState value) 09682 { 09683 m_eCurrentState = value; 09684 } 09685 09686 09687 09688 protected: 09689 CROBoundarySpec * m_pROBoundarySpec; 09690 09691 public: 09693 inline CROBoundarySpec * 09694 getROBoundarySpec (void) 09695 { 09696 return m_pROBoundarySpec; 09697 } 09698 09700 EResultCode 09701 setROBoundarySpec ( 09702 CROBoundarySpec * pValue); 09703 09704 09705 protected: 09706 std::list<CParameter *> m_listSpecParameter; 09707 09708 public: 09710 inline std::list<CParameter *>::iterator 09711 beginSpecParameter (void) 09712 { 09713 return m_listSpecParameter.begin(); 09714 } 09715 09717 inline std::list<CParameter *>::iterator 09718 endSpecParameter (void) 09719 { 09720 return m_listSpecParameter.end(); 09721 } 09722 09724 inline void 09725 clearSpecParameter (void) 09726 { 09727 clearSubParameterList ((tListOfParameters *) &m_listSpecParameter); 09728 } 09729 09731 inline int 09732 countSpecParameter (void) 09733 { 09734 return (int) (m_listSpecParameter.size()); 09735 } 09736 09737 EResultCode 09739 addSpecParameter ( 09740 CParameter * pValue); 09741 09742 09743 protected: 09744 CROReportSpec * m_pROReportSpec; 09745 09746 public: 09748 inline CROReportSpec * 09749 getROReportSpec (void) 09750 { 09751 return m_pROReportSpec; 09752 } 09753 09755 EResultCode 09756 setROReportSpec ( 09757 CROReportSpec * pValue); 09758 09759 09760 }; 09761 09762 09794 class CROBoundarySpec : public CParameter 09795 { 09796 public: 09797 CROBoundarySpec (void); 09798 ~CROBoundarySpec (void); 09799 09802 09803 static const CFieldDescriptor * const 09804 s_apFieldDescriptorTable[]; 09805 09806 static const CTypeDescriptor 09807 s_typeDescriptor; 09808 09809 void 09810 decodeFields ( 09811 CDecoderStream * pDecoderStream); 09812 09813 void 09814 assimilateSubParameters ( 09815 CErrorDetails * pError); 09816 09817 void 09818 encode ( 09819 CEncoderStream * pEncoderStream) const; 09820 09821 09822 09823 static CElement * 09824 s_construct (void); 09825 09826 static void 09827 s_decodeFields ( 09828 CDecoderStream * pDecoderStream, 09829 CElement * pElement); 09831 09832 09833 09834 protected: 09835 CROSpecStartTrigger * m_pROSpecStartTrigger; 09836 09837 public: 09839 inline CROSpecStartTrigger * 09840 getROSpecStartTrigger (void) 09841 { 09842 return m_pROSpecStartTrigger; 09843 } 09844 09846 EResultCode 09847 setROSpecStartTrigger ( 09848 CROSpecStartTrigger * pValue); 09849 09850 09851 protected: 09852 CROSpecStopTrigger * m_pROSpecStopTrigger; 09853 09854 public: 09856 inline CROSpecStopTrigger * 09857 getROSpecStopTrigger (void) 09858 { 09859 return m_pROSpecStopTrigger; 09860 } 09861 09863 EResultCode 09864 setROSpecStopTrigger ( 09865 CROSpecStopTrigger * pValue); 09866 09867 09868 }; 09869 09870 09903 class CROSpecStartTrigger : public CParameter 09904 { 09905 public: 09906 CROSpecStartTrigger (void); 09907 ~CROSpecStartTrigger (void); 09908 09911 09912 static const CFieldDescriptor * const 09913 s_apFieldDescriptorTable[]; 09914 09915 static const CTypeDescriptor 09916 s_typeDescriptor; 09917 09918 void 09919 decodeFields ( 09920 CDecoderStream * pDecoderStream); 09921 09922 void 09923 assimilateSubParameters ( 09924 CErrorDetails * pError); 09925 09926 void 09927 encode ( 09928 CEncoderStream * pEncoderStream) const; 09929 09930 09931 09932 static CElement * 09933 s_construct (void); 09934 09935 static void 09936 s_decodeFields ( 09937 CDecoderStream * pDecoderStream, 09938 CElement * pElement); 09940 09941 09942 protected: 09943 EROSpecStartTriggerType m_eROSpecStartTriggerType; 09944 09947 public: 09948 static const CFieldDescriptor 09949 s_fdROSpecStartTriggerType; 09951 09953 inline EROSpecStartTriggerType 09954 getROSpecStartTriggerType (void) 09955 { 09956 return m_eROSpecStartTriggerType; 09957 } 09958 09960 inline void 09961 setROSpecStartTriggerType ( 09962 EROSpecStartTriggerType value) 09963 { 09964 m_eROSpecStartTriggerType = value; 09965 } 09966 09967 09968 09969 protected: 09970 CPeriodicTriggerValue * m_pPeriodicTriggerValue; 09971 09972 public: 09974 inline CPeriodicTriggerValue * 09975 getPeriodicTriggerValue (void) 09976 { 09977 return m_pPeriodicTriggerValue; 09978 } 09979 09981 EResultCode 09982 setPeriodicTriggerValue ( 09983 CPeriodicTriggerValue * pValue); 09984 09985 09986 protected: 09987 CGPITriggerValue * m_pGPITriggerValue; 09988 09989 public: 09991 inline CGPITriggerValue * 09992 getGPITriggerValue (void) 09993 { 09994 return m_pGPITriggerValue; 09995 } 09996 09998 EResultCode 09999 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 10107 setOffset ( 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 10133 setPeriod ( 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 * 10147 getUTCTimestamp (void) 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 10257 getGPIPortNum (void) 10258 { 10259 return m_GPIPortNum; 10260 } 10261 10263 inline void 10264 setGPIPortNum ( 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 10283 getGPIEvent (void) 10284 { 10285 return m_GPIEvent; 10286 } 10287 10289 inline void 10290 setGPIEvent ( 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 10316 setTimeout ( 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 10410 getROSpecStopTriggerType (void) 10411 { 10412 return m_eROSpecStopTriggerType; 10413 } 10414 10416 inline void 10417 setROSpecStopTriggerType ( 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 10436 getDurationTriggerValue (void) 10437 { 10438 return m_DurationTriggerValue; 10439 } 10440 10442 inline void 10443 setDurationTriggerValue ( 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 * 10457 getGPITriggerValue (void) 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 10555 getAntennaIDs (void) 10556 { 10557 return m_AntennaIDs; 10558 } 10559 10561 inline void 10562 setAntennaIDs ( 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 * 10576 getAISpecStopTrigger (void) 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 10593 beginInventoryParameterSpec (void) 10594 { 10595 return m_listInventoryParameterSpec.begin(); 10596 } 10597 10599 inline std::list<CInventoryParameterSpec *>::iterator 10600 endInventoryParameterSpec (void) 10601 { 10602 return m_listInventoryParameterSpec.end(); 10603 } 10604 10606 inline void 10607 clearInventoryParameterSpec (void) 10608 { 10609 clearSubParameterList ((tListOfParameters *) &m_listInventoryParameterSpec); 10610 } 10611 10613 inline int 10614 countInventoryParameterSpec (void) 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 10631 beginCustom (void) 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 10645 clearCustom (void) 10646 { 10647 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10648 } 10649 10651 inline int 10652 countCustom (void) 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 10750 getAISpecStopTriggerType (void) 10751 { 10752 return m_eAISpecStopTriggerType; 10753 } 10754 10756 inline void 10757 setAISpecStopTriggerType ( 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 10776 getDurationTrigger (void) 10777 { 10778 return m_DurationTrigger; 10779 } 10780 10782 inline void 10783 setDurationTrigger ( 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 * 10797 getGPITriggerValue (void) 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 * 10814 getTagObservationTrigger (void) 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 10914 getTriggerType (void) 10915 { 10916 return m_eTriggerType; 10917 } 10918 10920 inline void 10921 setTriggerType ( 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 10940 getNumberOfTags (void) 10941 { 10942 return m_NumberOfTags; 10943 } 10944 10946 inline void 10947 setNumberOfTags ( 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 10966 getNumberOfAttempts (void) 10967 { 10968 return m_NumberOfAttempts; 10969 } 10970 10972 inline void 10973 setNumberOfAttempts ( 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 10999 setT ( 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 11025 setTimeout ( 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 11120 getInventoryParameterSpecID (void) 11121 { 11122 return m_InventoryParameterSpecID; 11123 } 11124 11126 inline void 11127 setInventoryParameterSpecID ( 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 11146 getProtocolID (void) 11147 { 11148 return m_eProtocolID; 11149 } 11150 11152 inline void 11153 setProtocolID ( 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 11167 beginAntennaConfiguration (void) 11168 { 11169 return m_listAntennaConfiguration.begin(); 11170 } 11171 11173 inline std::list<CAntennaConfiguration *>::iterator 11174 endAntennaConfiguration (void) 11175 { 11176 return m_listAntennaConfiguration.end(); 11177 } 11178 11180 inline void 11181 clearAntennaConfiguration (void) 11182 { 11183 clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration); 11184 } 11185 11187 inline int 11188 countAntennaConfiguration (void) 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 11205 beginCustom (void) 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 11219 clearCustom (void) 11220 { 11221 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11222 } 11223 11225 inline int 11226 countCustom (void) 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 11325 getAntennaID (void) 11326 { 11327 return m_AntennaID; 11328 } 11329 11331 inline void 11332 setAntennaID ( 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 11351 getStartFrequency (void) 11352 { 11353 return m_StartFrequency; 11354 } 11355 11357 inline void 11358 setStartFrequency ( 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 11377 getEndFrequency (void) 11378 { 11379 return m_EndFrequency; 11380 } 11381 11383 inline void 11384 setEndFrequency ( 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 * 11398 getRFSurveySpecStopTrigger (void) 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 11415 beginCustom (void) 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 11429 clearCustom (void) 11430 { 11431 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11432 } 11433 11435 inline int 11436 countCustom (void) 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 11533 getStopTriggerType (void) 11534 { 11535 return m_eStopTriggerType; 11536 } 11537 11539 inline void 11540 setStopTriggerType ( 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 11559 getDurationPeriod (void) 11560 { 11561 return m_DurationPeriod; 11562 } 11563 11565 inline void 11566 setDurationPeriod ( 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 11592 setN ( 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 11693 getAccessSpecID (void) 11694 { 11695 return m_AccessSpecID; 11696 } 11697 11699 inline void 11700 setAccessSpecID ( 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 11719 getAntennaID (void) 11720 { 11721 return m_AntennaID; 11722 } 11723 11725 inline void 11726 setAntennaID ( 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 11745 getProtocolID (void) 11746 { 11747 return m_eProtocolID; 11748 } 11749 11751 inline void 11752 setProtocolID ( 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 11771 getCurrentState (void) 11772 { 11773 return m_eCurrentState; 11774 } 11775 11777 inline void 11778 setCurrentState ( 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 11797 getROSpecID (void) 11798 { 11799 return m_ROSpecID; 11800 } 11801 11803 inline void 11804 setROSpecID ( 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 * 11818 getAccessSpecStopTrigger (void) 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 * 11835 getAccessCommand (void) 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 * 11852 getAccessReportSpec (void) 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 11869 beginCustom (void) 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 11883 clearCustom (void) 11884 { 11885 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11886 } 11887 11889 inline int 11890 countCustom (void) 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 11989 getAccessSpecStopTrigger (void) 11990 { 11991 return m_eAccessSpecStopTrigger; 11992 } 11993 11995 inline void 11996 setAccessSpecStopTrigger ( 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 12015 getOperationCountValue (void) 12016 { 12017 return m_OperationCountValue; 12018 } 12019 12021 inline void 12022 setOperationCountValue ( 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 * 12121 getAirProtocolTagSpec (void) 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 12138 beginAccessCommandOpSpec (void) 12139 { 12140 return m_listAccessCommandOpSpec.begin(); 12141 } 12142 12144 inline std::list<CParameter *>::iterator 12145 endAccessCommandOpSpec (void) 12146 { 12147 return m_listAccessCommandOpSpec.end(); 12148 } 12149 12151 inline void 12152 clearAccessCommandOpSpec (void) 12153 { 12154 clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpec); 12155 } 12156 12158 inline int 12159 countAccessCommandOpSpec (void) 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 12176 beginCustom (void) 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 12190 clearCustom (void) 12191 { 12192 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12193 } 12194 12196 inline int 12197 countCustom (void) 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 12295 getOpSpecID (void) 12296 { 12297 return m_OpSpecID; 12298 } 12299 12301 inline void 12302 setOpSpecID ( 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 12396 getAccessSpecID (void) 12397 { 12398 return m_AccessSpecID; 12399 } 12400 12402 inline void 12403 setAccessSpecID ( 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 12434 beginAirProtocolOpSpec (void) 12435 { 12436 return m_listAirProtocolOpSpec.begin(); 12437 } 12438 12440 inline std::list<CParameter *>::iterator 12441 endAirProtocolOpSpec (void) 12442 { 12443 return m_listAirProtocolOpSpec.end(); 12444 } 12445 12447 inline void 12448 clearAirProtocolOpSpec (void) 12449 { 12450 clearSubParameterList ((tListOfParameters *) &m_listAirProtocolOpSpec); 12451 } 12452 12454 inline int 12455 countAirProtocolOpSpec (void) 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: 12536 CLLRPConfigurationStateValue (void); 12537 ~CLLRPConfigurationStateValue (void); 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 12584 getLLRPConfigurationStateValue (void) 12585 { 12586 return m_LLRPConfigurationStateValue; 12587 } 12588 12590 inline void 12591 setLLRPConfigurationStateValue ( 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 12696 setIDType ( 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 12715 getReaderID (void) 12716 { 12717 return m_ReaderID; 12718 } 12719 12721 inline void 12722 setReaderID ( 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 12823 getGPOPortNumber (void) 12824 { 12825 return m_GPOPortNumber; 12826 } 12827 12829 inline void 12830 setGPOPortNumber ( 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 12856 setGPOData ( 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 12949 getKeepaliveTriggerType (void) 12950 { 12951 return m_eKeepaliveTriggerType; 12952 } 12953 12955 inline void 12956 setKeepaliveTriggerType ( 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 12975 getPeriodicTriggerValue (void) 12976 { 12977 return m_PeriodicTriggerValue; 12978 } 12979 12981 inline void 12982 setPeriodicTriggerValue ( 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 13077 getAntennaConnected (void) 13078 { 13079 return m_AntennaConnected; 13080 } 13081 13083 inline void 13084 setAntennaConnected ( 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 13103 getAntennaID (void) 13104 { 13105 return m_AntennaID; 13106 } 13107 13109 inline void 13110 setAntennaID ( 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 13129 getAntennaGain (void) 13130 { 13131 return m_AntennaGain; 13132 } 13133 13135 inline void 13136 setAntennaGain ( 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 13231 getAntennaID (void) 13232 { 13233 return m_AntennaID; 13234 } 13235 13237 inline void 13238 setAntennaID ( 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 * 13252 getRFReceiver (void) 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 * 13269 getRFTransmitter (void) 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 13286 beginAirProtocolInventoryCommandSettings (void) 13287 { 13288 return m_listAirProtocolInventoryCommandSettings.begin(); 13289 } 13290 13292 inline std::list<CParameter *>::iterator 13293 endAirProtocolInventoryCommandSettings (void) 13294 { 13295 return m_listAirProtocolInventoryCommandSettings.end(); 13296 } 13297 13299 inline void 13300 clearAirProtocolInventoryCommandSettings (void) 13301 { 13302 clearSubParameterList ((tListOfParameters *) &m_listAirProtocolInventoryCommandSettings); 13303 } 13304 13306 inline int 13307 countAirProtocolInventoryCommandSettings (void) 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 13402 getReceiverSensitivity (void) 13403 { 13404 return m_ReceiverSensitivity; 13405 } 13406 13408 inline void 13409 setReceiverSensitivity ( 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 13503 getHopTableID (void) 13504 { 13505 return m_HopTableID; 13506 } 13507 13509 inline void 13510 setHopTableID ( 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 13529 getChannelIndex (void) 13530 { 13531 return m_ChannelIndex; 13532 } 13533 13535 inline void 13536 setChannelIndex ( 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 13555 getTransmitPower (void) 13556 { 13557 return m_TransmitPower; 13558 } 13559 13561 inline void 13562 setTransmitPower ( 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 13667 getGPIPortNum (void) 13668 { 13669 return m_GPIPortNum; 13670 } 13671 13673 inline void 13674 setGPIPortNum ( 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 13700 setConfig ( 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 13726 setState ( 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 13819 getHoldEventsAndReportsUponReconnect (void) 13820 { 13821 return m_HoldEventsAndReportsUponReconnect; 13822 } 13823 13825 inline void 13826 setHoldEventsAndReportsUponReconnect ( 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 13930 getROReportTrigger (void) 13931 { 13932 return m_eROReportTrigger; 13933 } 13934 13936 inline void 13937 setROReportTrigger ( 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 13963 setN ( 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 * 13977 getTagReportContentSelector (void) 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 13994 beginCustom (void) 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 14008 clearCustom (void) 14009 { 14010 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14011 } 14012 14014 inline int 14015 countCustom (void) 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: 14073 CTagReportContentSelector (void); 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 14121 getEnableROSpecID (void) 14122 { 14123 return m_EnableROSpecID; 14124 } 14125 14127 inline void 14128 setEnableROSpecID ( 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 14147 getEnableSpecIndex (void) 14148 { 14149 return m_EnableSpecIndex; 14150 } 14151 14153 inline void 14154 setEnableSpecIndex ( 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 14173 getEnableInventoryParameterSpecID (void) 14174 { 14175 return m_EnableInventoryParameterSpecID; 14176 } 14177 14179 inline void 14180 setEnableInventoryParameterSpecID ( 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 14199 getEnableAntennaID (void) 14200 { 14201 return m_EnableAntennaID; 14202 } 14203 14205 inline void 14206 setEnableAntennaID ( 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 14225 getEnableChannelIndex (void) 14226 { 14227 return m_EnableChannelIndex; 14228 } 14229 14231 inline void 14232 setEnableChannelIndex ( 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 14251 getEnablePeakRSSI (void) 14252 { 14253 return m_EnablePeakRSSI; 14254 } 14255 14257 inline void 14258 setEnablePeakRSSI ( 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 14277 getEnableFirstSeenTimestamp (void) 14278 { 14279 return m_EnableFirstSeenTimestamp; 14280 } 14281 14283 inline void 14284 setEnableFirstSeenTimestamp ( 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 14303 getEnableLastSeenTimestamp (void) 14304 { 14305 return m_EnableLastSeenTimestamp; 14306 } 14307 14309 inline void 14310 setEnableLastSeenTimestamp ( 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 14329 getEnableTagSeenCount (void) 14330 { 14331 return m_EnableTagSeenCount; 14332 } 14333 14335 inline void 14336 setEnableTagSeenCount ( 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 14355 getEnableAccessSpecID (void) 14356 { 14357 return m_EnableAccessSpecID; 14358 } 14359 14361 inline void 14362 setEnableAccessSpecID ( 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 14376 beginAirProtocolEPCMemorySelector (void) 14377 { 14378 return m_listAirProtocolEPCMemorySelector.begin(); 14379 } 14380 14382 inline std::list<CParameter *>::iterator 14383 endAirProtocolEPCMemorySelector (void) 14384 { 14385 return m_listAirProtocolEPCMemorySelector.end(); 14386 } 14387 14389 inline void 14390 clearAirProtocolEPCMemorySelector (void) 14391 { 14392 clearSubParameterList ((tListOfParameters *) &m_listAirProtocolEPCMemorySelector); 14393 } 14394 14396 inline int 14397 countAirProtocolEPCMemorySelector (void) 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 14492 getAccessReportTrigger (void) 14493 { 14494 return m_eAccessReportTrigger; 14495 } 14496 14498 inline void 14499 setAccessReportTrigger ( 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 * 14725 getEPCParameter (void) 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 * 14742 getROSpecID (void) 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 * 14759 getSpecIndex (void) 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 * 14776 getInventoryParameterSpecID (void) 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 * 14793 getAntennaID (void) 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 * 14810 getPeakRSSI (void) 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 * 14827 getChannelIndex (void) 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 * 14844 getFirstSeenTimestampUTC (void) 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 * 14861 getFirstSeenTimestampUptime (void) 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 * 14878 getLastSeenTimestampUTC (void) 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 * 14895 getLastSeenTimestampUptime (void) 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 * 14912 getTagSeenCount (void) 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 14929 beginAirProtocolTagData (void) 14930 { 14931 return m_listAirProtocolTagData.begin(); 14932 } 14933 14935 inline std::list<CParameter *>::iterator 14936 endAirProtocolTagData (void) 14937 { 14938 return m_listAirProtocolTagData.end(); 14939 } 14940 14942 inline void 14943 clearAirProtocolTagData (void) 14944 { 14945 clearSubParameterList ((tListOfParameters *) &m_listAirProtocolTagData); 14946 } 14947 14949 inline int 14950 countAirProtocolTagData (void) 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 * 14967 getAccessSpecID (void) 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 14984 beginAccessCommandOpSpecResult (void) 14985 { 14986 return m_listAccessCommandOpSpecResult.begin(); 14987 } 14988 14990 inline std::list<CParameter *>::iterator 14991 endAccessCommandOpSpecResult (void) 14992 { 14993 return m_listAccessCommandOpSpecResult.end(); 14994 } 14995 14997 inline void 14998 clearAccessCommandOpSpecResult (void) 14999 { 15000 clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpecResult); 15001 } 15002 15004 inline int 15005 countAccessCommandOpSpecResult (void) 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 15022 beginCustom (void) 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 15036 clearCustom (void) 15037 { 15038 clearSubParameterList ((tListOfParameters *) &m_listCustom); 15039 } 15040 15042 inline int 15043 countCustom (void) 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 15145 setEPC ( 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 15244 setEPC ( 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 15336 getROSpecID (void) 15337 { 15338 return m_ROSpecID; 15339 } 15340 15342 inline void 15343 setROSpecID ( 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 15435 getSpecIndex (void) 15436 { 15437 return m_SpecIndex; 15438 } 15439 15441 inline void 15442 setSpecIndex ( 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: 15486 CInventoryParameterSpecID (void); 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 15534 getInventoryParameterSpecID (void) 15535 { 15536 return m_InventoryParameterSpecID; 15537 } 15538 15540 inline void 15541 setInventoryParameterSpecID ( 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 15633 getAntennaID (void) 15634 { 15635 return m_AntennaID; 15636 } 15637 15639 inline void 15640 setAntennaID ( 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 15735 getPeakRSSI (void) 15736 { 15737 return m_PeakRSSI; 15738 } 15739 15741 inline void 15742 setPeakRSSI ( 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 15834 getChannelIndex (void) 15835 { 15836 return m_ChannelIndex; 15837 } 15838 15840 inline void 15841 setChannelIndex ( 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 15941 getMicroseconds (void) 15942 { 15943 return m_Microseconds; 15944 } 15945 15947 inline void 15948 setMicroseconds ( 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: 15999 CFirstSeenTimestampUptime (void); 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 16047 getMicroseconds (void) 16048 { 16049 return m_Microseconds; 16050 } 16051 16053 inline void 16054 setMicroseconds ( 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 16149 getMicroseconds (void) 16150 { 16151 return m_Microseconds; 16152 } 16153 16155 inline void 16156 setMicroseconds ( 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 16251 getMicroseconds (void) 16252 { 16253 return m_Microseconds; 16254 } 16255 16257 inline void 16258 setMicroseconds ( 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 16352 getTagCount (void) 16353 { 16354 return m_TagCount; 16355 } 16356 16358 inline void 16359 setTagCount ( 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: 16400 CClientRequestOpSpecResult (void); 16401 ~CClientRequestOpSpecResult (void); 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 16448 getOpSpecID (void) 16449 { 16450 return m_OpSpecID; 16451 } 16452 16454 inline void 16455 setOpSpecID ( 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 16547 getAccessSpecID (void) 16548 { 16549 return m_AccessSpecID; 16550 } 16551 16553 inline void 16554 setAccessSpecID ( 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 * 16644 getROSpecID (void) 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 * 16661 getSpecIndex (void) 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 16678 beginFrequencyRSSILevelEntry (void) 16679 { 16680 return m_listFrequencyRSSILevelEntry.begin(); 16681 } 16682 16684 inline std::list<CFrequencyRSSILevelEntry *>::iterator 16685 endFrequencyRSSILevelEntry (void) 16686 { 16687 return m_listFrequencyRSSILevelEntry.end(); 16688 } 16689 16691 inline void 16692 clearFrequencyRSSILevelEntry (void) 16693 { 16694 clearSubParameterList ((tListOfParameters *) &m_listFrequencyRSSILevelEntry); 16695 } 16696 16698 inline int 16699 countFrequencyRSSILevelEntry (void) 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 16716 beginCustom (void) 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 16730 clearCustom (void) 16731 { 16732 clearSubParameterList ((tListOfParameters *) &m_listCustom); 16733 } 16734 16736 inline int 16737 countCustom (void) 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 16860 getFrequency (void) 16861 { 16862 return m_Frequency; 16863 } 16864 16866 inline void 16867 setFrequency ( 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 16886 getBandwidth (void) 16887 { 16888 return m_Bandwidth; 16889 } 16890 16892 inline void 16893 setBandwidth ( 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 16912 getAverageRSSI (void) 16913 { 16914 return m_AverageRSSI; 16915 } 16916 16918 inline void 16919 setAverageRSSI ( 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 16938 getPeakRSSI (void) 16939 { 16940 return m_PeakRSSI; 16941 } 16942 16944 inline void 16945 setPeakRSSI ( 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 * 16959 getTimestamp (void) 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: 17006 CReaderEventNotificationSpec (void); 17007 ~CReaderEventNotificationSpec (void); 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 17049 beginEventNotificationState (void) 17050 { 17051 return m_listEventNotificationState.begin(); 17052 } 17053 17055 inline std::list<CEventNotificationState *>::iterator 17056 endEventNotificationState (void) 17057 { 17058 return m_listEventNotificationState.end(); 17059 } 17060 17062 inline void 17063 clearEventNotificationState (void) 17064 { 17065 clearSubParameterList ((tListOfParameters *) &m_listEventNotificationState); 17066 } 17067 17069 inline int 17070 countEventNotificationState (void) 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 17167 getEventType (void) 17168 { 17169 return m_eEventType; 17170 } 17171 17173 inline void 17174 setEventType ( 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 17193 getNotificationState (void) 17194 { 17195 return m_NotificationState; 17196 } 17197 17199 inline void 17200 setNotificationState ( 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: 17323 CReaderEventNotificationData (void); 17324 ~CReaderEventNotificationData (void); 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 * 17366 getTimestamp (void) 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 * 17383 getHoppingEvent (void) 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 * 17400 getGPIEvent (void) 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 * 17417 getROSpecEvent (void) 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: 17433 inline CReportBufferLevelWarningEvent * 17434 getReportBufferLevelWarningEvent (void) 17435 { 17436 return m_pReportBufferLevelWarningEvent; 17437 } 17438 17440 EResultCode 17441 setReportBufferLevelWarningEvent ( 17442 CReportBufferLevelWarningEvent * pValue); 17443 17444 17445 protected: 17446 CReportBufferOverflowErrorEvent * m_pReportBufferOverflowErrorEvent; 17447 17448 public: 17450 inline CReportBufferOverflowErrorEvent * 17451 getReportBufferOverflowErrorEvent (void) 17452 { 17453 return m_pReportBufferOverflowErrorEvent; 17454 } 17455 17457 EResultCode 17458 setReportBufferOverflowErrorEvent ( 17459 CReportBufferOverflowErrorEvent * pValue); 17460 17461 17462 protected: 17463 CReaderExceptionEvent * m_pReaderExceptionEvent; 17464 17465 public: 17467 inline CReaderExceptionEvent * 17468 getReaderExceptionEvent (void) 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 * 17485 getRFSurveyEvent (void) 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 * 17502 getAISpecEvent (void) 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 * 17519 getAntennaEvent (void) 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 * 17536 getConnectionAttemptEvent (void) 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 * 17553 getConnectionCloseEvent (void) 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 17570 beginCustom (void) 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 17584 clearCustom (void) 17585 { 17586 clearSubParameterList ((tListOfParameters *) &m_listCustom); 17587 } 17588 17590 inline int 17591 countCustom (void) 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 17690 getHopTableID (void) 17691 { 17692 return m_HopTableID; 17693 } 17694 17696 inline void 17697 setHopTableID ( 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 17716 getNextChannelIndex (void) 17717 { 17718 return m_NextChannelIndex; 17719 } 17720 17722 inline void 17723 setNextChannelIndex ( 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 17817 getGPIPortNumber (void) 17818 { 17819 return m_GPIPortNumber; 17820 } 17821 17823 inline void 17824 setGPIPortNumber ( 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 17843 getGPIEvent (void) 17844 { 17845 return m_GPIEvent; 17846 } 17847 17849 inline void 17850 setGPIEvent ( 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 17947 getEventType (void) 17948 { 17949 return m_eEventType; 17950 } 17951 17953 inline void 17954 setEventType ( 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 17973 getROSpecID (void) 17974 { 17975 return m_ROSpecID; 17976 } 17977 17979 inline void 17980 setROSpecID ( 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 17999 getPreemptingROSpecID (void) 18000 { 18001 return m_PreemptingROSpecID; 18002 } 18003 18005 inline void 18006 setPreemptingROSpecID ( 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: 18057 CReportBufferLevelWarningEvent (void); 18058 ~CReportBufferLevelWarningEvent (void); 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 18105 getReportBufferPercentageFull (void) 18106 { 18107 return m_ReportBufferPercentageFull; 18108 } 18109 18111 inline void 18112 setReportBufferPercentageFull ( 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: 18160 CReportBufferOverflowErrorEvent (void); 18161 ~CReportBufferOverflowErrorEvent (void); 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 18295 setMessage ( 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 * 18309 getROSpecID (void) 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 * 18326 getSpecIndex (void) 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 * 18343 getInventoryParameterSpecID (void) 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 * 18360 getAntennaID (void) 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 * 18377 getAccessSpecID (void) 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 * 18394 getOpSpecID (void) 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 18411 beginCustom (void) 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 18425 clearCustom (void) 18426 { 18427 clearSubParameterList ((tListOfParameters *) &m_listCustom); 18428 } 18429 18431 inline int 18432 countCustom (void) 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 18527 getOpSpecID (void) 18528 { 18529 return m_OpSpecID; 18530 } 18531 18533 inline void 18534 setOpSpecID ( 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 18628 getEventType (void) 18629 { 18630 return m_eEventType; 18631 } 18632 18634 inline void 18635 setEventType ( 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 18654 getROSpecID (void) 18655 { 18656 return m_ROSpecID; 18657 } 18658 18660 inline void 18661 setROSpecID ( 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 18680 getSpecIndex (void) 18681 { 18682 return m_SpecIndex; 18683 } 18684 18686 inline void 18687 setSpecIndex ( 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 18784 getEventType (void) 18785 { 18786 return m_eEventType; 18787 } 18788 18790 inline void 18791 setEventType ( 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 18810 getROSpecID (void) 18811 { 18812 return m_ROSpecID; 18813 } 18814 18816 inline void 18817 setROSpecID ( 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 18836 getSpecIndex (void) 18837 { 18838 return m_SpecIndex; 18839 } 18840 18842 inline void 18843 setSpecIndex ( 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 * 18857 getAirProtocolSingulationDetails (void) 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 18953 getEventType (void) 18954 { 18955 return m_eEventType; 18956 } 18957 18959 inline void 18960 setEventType ( 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 18979 getAntennaID (void) 18980 { 18981 return m_AntennaID; 18982 } 18983 18985 inline void 18986 setAntennaID ( 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 19085 setStatus ( 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 19256 getStatusCode (void) 19257 { 19258 return m_eStatusCode; 19259 } 19260 19262 inline void 19263 setStatusCode ( 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 19282 getErrorDescription (void) 19283 { 19284 return m_ErrorDescription; 19285 } 19286 19288 inline void 19289 setErrorDescription ( 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 * 19303 getFieldError (void) 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 * 19320 getParameterError (void) 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 19416 getFieldNum (void) 19417 { 19418 return m_FieldNum; 19419 } 19420 19422 inline void 19423 setFieldNum ( 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 19442 getErrorCode (void) 19443 { 19444 return m_eErrorCode; 19445 } 19446 19448 inline void 19449 setErrorCode ( 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 19544 getParameterType (void) 19545 { 19546 return m_ParameterType; 19547 } 19548 19550 inline void 19551 setParameterType ( 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 19570 getErrorCode (void) 19571 { 19572 return m_eErrorCode; 19573 } 19574 19576 inline void 19577 setErrorCode ( 19578 EStatusCode value) 19579 { 19580 m_eErrorCode = value; 19581 } 19582 19583 19584 19585 protected: 19586 CFieldError * m_pFieldError; 19587 19588 public: 19590 inline CFieldError * 19591 getFieldError (void) 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 * 19608 getParameterError (void) 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 19712 getCanSupportBlockErase (void) 19713 { 19714 return m_CanSupportBlockErase; 19715 } 19716 19718 inline void 19719 setCanSupportBlockErase ( 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 19738 getCanSupportBlockWrite (void) 19739 { 19740 return m_CanSupportBlockWrite; 19741 } 19742 19744 inline void 19745 setCanSupportBlockWrite ( 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 19764 getMaxNumSelectFiltersPerQuery (void) 19765 { 19766 return m_MaxNumSelectFiltersPerQuery; 19767 } 19768 19770 inline void 19771 setMaxNumSelectFiltersPerQuery ( 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 19858 beginC1G2UHFRFModeTableEntry (void) 19859 { 19860 return m_listC1G2UHFRFModeTableEntry.begin(); 19861 } 19862 19864 inline std::list<CC1G2UHFRFModeTableEntry *>::iterator 19865 endC1G2UHFRFModeTableEntry (void) 19866 { 19867 return m_listC1G2UHFRFModeTableEntry.end(); 19868 } 19869 19871 inline void 19872 clearC1G2UHFRFModeTableEntry (void) 19873 { 19874 clearSubParameterList ((tListOfParameters *) &m_listC1G2UHFRFModeTableEntry); 19875 } 19876 19878 inline int 19879 countC1G2UHFRFModeTableEntry (void) 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 19985 getModeIdentifier (void) 19986 { 19987 return m_ModeIdentifier; 19988 } 19989 19991 inline void 19992 setModeIdentifier ( 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 20018 setDRValue ( 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 20037 getEPCHAGTCConformance (void) 20038 { 20039 return m_EPCHAGTCConformance; 20040 } 20041 20043 inline void 20044 setEPCHAGTCConformance ( 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 20070 setMValue ( 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 20089 getForwardLinkModulation (void) 20090 { 20091 return m_eForwardLinkModulation; 20092 } 20093 20095 inline void 20096 setForwardLinkModulation ( 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 20115 getSpectralMaskIndicator (void) 20116 { 20117 return m_eSpectralMaskIndicator; 20118 } 20119 20121 inline void 20122 setSpectralMaskIndicator ( 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 20141 getBDRValue (void) 20142 { 20143 return m_BDRValue; 20144 } 20145 20147 inline void 20148 setBDRValue ( 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 20167 getPIEValue (void) 20168 { 20169 return m_PIEValue; 20170 } 20171 20173 inline void 20174 setPIEValue ( 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 20193 getMinTariValue (void) 20194 { 20195 return m_MinTariValue; 20196 } 20197 20199 inline void 20200 setMinTariValue ( 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 20219 getMaxTariValue (void) 20220 { 20221 return m_MaxTariValue; 20222 } 20223 20225 inline void 20226 setMaxTariValue ( 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 20245 getStepTariValue (void) 20246 { 20247 return m_StepTariValue; 20248 } 20249 20251 inline void 20252 setStepTariValue ( 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 20354 getTagInventoryStateAware (void) 20355 { 20356 return m_TagInventoryStateAware; 20357 } 20358 20360 inline void 20361 setTagInventoryStateAware ( 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 20375 beginC1G2Filter (void) 20376 { 20377 return m_listC1G2Filter.begin(); 20378 } 20379 20381 inline std::list<CC1G2Filter *>::iterator 20382 endC1G2Filter (void) 20383 { 20384 return m_listC1G2Filter.end(); 20385 } 20386 20388 inline void 20389 clearC1G2Filter (void) 20390 { 20391 clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter); 20392 } 20393 20395 inline int 20396 countC1G2Filter (void) 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 * 20413 getC1G2RFControl (void) 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 * 20430 getC1G2SingulationControl (void) 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 20447 beginCustom (void) 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 20461 clearCustom (void) 20462 { 20463 clearSubParameterList ((tListOfParameters *) &m_listCustom); 20464 } 20465 20467 inline int 20468 countCustom (void) 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 20598 setT ( 20599 EC1G2TruncateAction value) 20600 { 20601 m_eT = value; 20602 } 20603 20604 20605 20606 protected: 20607 CC1G2TagInventoryMask * m_pC1G2TagInventoryMask; 20608 20609 public: 20611 inline CC1G2TagInventoryMask * 20612 getC1G2TagInventoryMask (void) 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: 20628 inline CC1G2TagInventoryStateAwareFilterAction * 20629 getC1G2TagInventoryStateAwareFilterAction (void) 20630 { 20631 return m_pC1G2TagInventoryStateAwareFilterAction; 20632 } 20633 20635 EResultCode 20636 setC1G2TagInventoryStateAwareFilterAction ( 20637 CC1G2TagInventoryStateAwareFilterAction * pValue); 20638 20639 20640 protected: 20641 CC1G2TagInventoryStateUnawareFilterAction * m_pC1G2TagInventoryStateUnawareFilterAction; 20642 20643 public: 20645 inline CC1G2TagInventoryStateUnawareFilterAction * 20646 getC1G2TagInventoryStateUnawareFilterAction (void) 20647 { 20648 return m_pC1G2TagInventoryStateUnawareFilterAction; 20649 } 20650 20652 EResultCode 20653 setC1G2TagInventoryStateUnawareFilterAction ( 20654 CC1G2TagInventoryStateUnawareFilterAction * pValue); 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 20744 setMB ( 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 20770 setPointer ( 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 20796 setTagMask ( 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: 20860 CC1G2TagInventoryStateAwareFilterAction (void); 20861 ~CC1G2TagInventoryStateAwareFilterAction (void); 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 20915 setTarget ( 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 20941 setAction ( 20942 EC1G2StateAwareAction value) 20943 { 20944 m_eAction = value; 20945 } 20946 20947 20948 20949 }; 20950 20951 20994 class CC1G2TagInventoryStateUnawareFilterAction : public CParameter 20995 { 20996 public: 20997 CC1G2TagInventoryStateUnawareFilterAction (void); 20998 ~CC1G2TagInventoryStateUnawareFilterAction (void); 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 21052 setAction ( 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 21148 getModeIndex (void) 21149 { 21150 return m_ModeIndex; 21151 } 21152 21154 inline void 21155 setModeIndex ( 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 21181 setTari ( 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 21334 setSession ( 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 21353 getTagPopulation (void) 21354 { 21355 return m_TagPopulation; 21356 } 21357 21359 inline void 21360 setTagPopulation ( 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 21379 getTagTransitTime (void) 21380 { 21381 return m_TagTransitTime; 21382 } 21383 21385 inline void 21386 setTagTransitTime ( 21387 llrp_u32_t value) 21388 { 21389 m_TagTransitTime = value; 21390 } 21391 21392 21393 21394 protected: 21395 CC1G2TagInventoryStateAwareSingulationAction * m_pC1G2TagInventoryStateAwareSingulationAction; 21396 21397 public: 21399 inline CC1G2TagInventoryStateAwareSingulationAction * 21400 getC1G2TagInventoryStateAwareSingulationAction (void) 21401 { 21402 return m_pC1G2TagInventoryStateAwareSingulationAction; 21403 } 21404 21406 EResultCode 21407 setC1G2TagInventoryStateAwareSingulationAction ( 21408 CC1G2TagInventoryStateAwareSingulationAction * pValue); 21409 21410 21411 }; 21412 21413 21446 class CC1G2TagInventoryStateAwareSingulationAction : public CParameter 21447 { 21448 public: 21449 CC1G2TagInventoryStateAwareSingulationAction (void); 21450 ~CC1G2TagInventoryStateAwareSingulationAction (void); 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 21504 setI ( 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 21530 setS ( 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 21623 beginC1G2TargetTag (void) 21624 { 21625 return m_listC1G2TargetTag.begin(); 21626 } 21627 21629 inline std::list<CC1G2TargetTag *>::iterator 21630 endC1G2TargetTag (void) 21631 { 21632 return m_listC1G2TargetTag.end(); 21633 } 21634 21636 inline void 21637 clearC1G2TargetTag (void) 21638 { 21639 clearSubParameterList ((tListOfParameters *) &m_listC1G2TargetTag); 21640 } 21641 21643 inline int 21644 countC1G2TargetTag (void) 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 21751 setMB ( 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 21777 setMatch ( 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 21803 setPointer ( 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 21829 setTagMask ( 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 21855 setTagData ( 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 21955 getOpSpecID (void) 21956 { 21957 return m_OpSpecID; 21958 } 21959 21961 inline void 21962 setOpSpecID ( 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 21981 getAccessPassword (void) 21982 { 21983 return m_AccessPassword; 21984 } 21985 21987 inline void 21988 setAccessPassword ( 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 22014 setMB ( 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 22033 getWordPointer (void) 22034 { 22035 return m_WordPointer; 22036 } 22037 22039 inline void 22040 setWordPointer ( 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 22059 getWordCount (void) 22060 { 22061 return m_WordCount; 22062 } 22063 22065 inline void 22066 setWordCount ( 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 22163 getOpSpecID (void) 22164 { 22165 return m_OpSpecID; 22166 } 22167 22169 inline void 22170 setOpSpecID ( 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 22189 getAccessPassword (void) 22190 { 22191 return m_AccessPassword; 22192 } 22193 22195 inline void 22196 setAccessPassword ( 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 22222 setMB ( 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 22241 getWordPointer (void) 22242 { 22243 return m_WordPointer; 22244 } 22245 22247 inline void 22248 setWordPointer ( 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 22267 getWriteData (void) 22268 { 22269 return m_WriteData; 22270 } 22271 22273 inline void 22274 setWriteData ( 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 22367 getOpSpecID (void) 22368 { 22369 return m_OpSpecID; 22370 } 22371 22373 inline void 22374 setOpSpecID ( 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 22393 getKillPassword (void) 22394 { 22395 return m_KillPassword; 22396 } 22397 22399 inline void 22400 setKillPassword ( 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 22497 getOpSpecID (void) 22498 { 22499 return m_OpSpecID; 22500 } 22501 22503 inline void 22504 setOpSpecID ( 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 22523 getAccessPassword (void) 22524 { 22525 return m_AccessPassword; 22526 } 22527 22529 inline void 22530 setAccessPassword ( 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 22544 beginC1G2LockPayload (void) 22545 { 22546 return m_listC1G2LockPayload.begin(); 22547 } 22548 22550 inline std::list<CC1G2LockPayload *>::iterator 22551 endC1G2LockPayload (void) 22552 { 22553 return m_listC1G2LockPayload.end(); 22554 } 22555 22557 inline void 22558 clearC1G2LockPayload (void) 22559 { 22560 clearSubParameterList ((tListOfParameters *) &m_listC1G2LockPayload); 22561 } 22562 22564 inline int 22565 countC1G2LockPayload (void) 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 22661 getPrivilege (void) 22662 { 22663 return m_ePrivilege; 22664 } 22665 22667 inline void 22668 setPrivilege ( 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 22687 getDataField (void) 22688 { 22689 return m_eDataField; 22690 } 22691 22693 inline void 22694 setDataField ( 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 22798 getOpSpecID (void) 22799 { 22800 return m_OpSpecID; 22801 } 22802 22804 inline void 22805 setOpSpecID ( 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 22824 getAccessPassword (void) 22825 { 22826 return m_AccessPassword; 22827 } 22828 22830 inline void 22831 setAccessPassword ( 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 22857 setMB ( 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 22876 getWordPointer (void) 22877 { 22878 return m_WordPointer; 22879 } 22880 22882 inline void 22883 setWordPointer ( 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 22902 getWordCount (void) 22903 { 22904 return m_WordCount; 22905 } 22906 22908 inline void 22909 setWordCount ( 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 23013 getOpSpecID (void) 23014 { 23015 return m_OpSpecID; 23016 } 23017 23019 inline void 23020 setOpSpecID ( 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 23039 getAccessPassword (void) 23040 { 23041 return m_AccessPassword; 23042 } 23043 23045 inline void 23046 setAccessPassword ( 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 23072 setMB ( 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 23091 getWordPointer (void) 23092 { 23093 return m_WordPointer; 23094 } 23095 23097 inline void 23098 setWordPointer ( 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 23117 getWriteData (void) 23118 { 23119 return m_WriteData; 23120 } 23121 23123 inline void 23124 setWriteData ( 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 23218 getEnableCRC (void) 23219 { 23220 return m_EnableCRC; 23221 } 23222 23224 inline void 23225 setEnableCRC ( 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 23244 getEnablePCBits (void) 23245 { 23246 return m_EnablePCBits; 23247 } 23248 23250 inline void 23251 setEnablePCBits ( 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 23350 setPC_Bits ( 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 23449 setCRC ( 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 23535 getNumCollisionSlots (void) 23536 { 23537 return m_NumCollisionSlots; 23538 } 23539 23541 inline void 23542 setNumCollisionSlots ( 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 23561 getNumEmptySlots (void) 23562 { 23563 return m_NumEmptySlots; 23564 } 23565 23567 inline void 23568 setNumEmptySlots ( 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 23669 setResult ( 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 23688 getOpSpecID (void) 23689 { 23690 return m_OpSpecID; 23691 } 23692 23694 inline void 23695 setOpSpecID ( 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 23714 getReadData (void) 23715 { 23716 return m_ReadData; 23717 } 23718 23720 inline void 23721 setReadData ( 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 23827 setResult ( 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 23846 getOpSpecID (void) 23847 { 23848 return m_OpSpecID; 23849 } 23850 23852 inline void 23853 setOpSpecID ( 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 23872 getNumWordsWritten (void) 23873 { 23874 return m_NumWordsWritten; 23875 } 23876 23878 inline void 23879 setNumWordsWritten ( 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 23977 setResult ( 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 23996 getOpSpecID (void) 23997 { 23998 return m_OpSpecID; 23999 } 24000 24002 inline void 24003 setOpSpecID ( 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 24103 setResult ( 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 24122 getOpSpecID (void) 24123 { 24124 return m_OpSpecID; 24125 } 24126 24128 inline void 24129 setOpSpecID ( 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: 24181 CC1G2BlockEraseOpSpecResult (void); 24182 ~CC1G2BlockEraseOpSpecResult (void); 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 24236 setResult ( 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 24255 getOpSpecID (void) 24256 { 24257 return m_OpSpecID; 24258 } 24259 24261 inline void 24262 setOpSpecID ( 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: 24315 CC1G2BlockWriteOpSpecResult (void); 24316 ~CC1G2BlockWriteOpSpecResult (void); 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 24370 setResult ( 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 24389 getOpSpecID (void) 24390 { 24391 return m_OpSpecID; 24392 } 24393 24395 inline void 24396 setOpSpecID ( 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 24415 getNumWordsWritten (void) 24416 { 24417 return m_NumWordsWritten; 24418 } 24419 24421 inline void 24422 setNumWordsWritten ( 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 24658 enrollCoreTypesIntoRegistry ( 24659 CTypeRegistry * pTypeRegistry);