LTKCPP-- LLRP Toolkit C Plus Plus Library
out_ltkcpp.h
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);