LTKCPP-- LLRP Toolkit C Plus Plus Library
|
00001 00002 /* 00003 * Generated file - DO NOT EDIT 00004 * 00005 * This is the header file for the LLRP Tool Kit (LTK) 00006 * C++ (aka cpp) implementation. It is generated into a .inc file 00007 * that is included by a platform specific .h header file. 00008 * That .h file takes care of prerequisites needed by this file. 00009 */ 00010 00011 00012 /* 00013 * Message classes - forward decls 00014 */ 00015 00016 00017 /* Custom messages */ 00018 00019 class CIMPINJ_ENABLE_EXTENSIONS; 00020 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE; 00021 class CIMPINJ_SAVE_SETTINGS; 00022 class CIMPINJ_SAVE_SETTINGS_RESPONSE; 00023 00024 /* 00025 * Parameter classes - forward decls 00026 */ 00027 00028 00029 /* Custom parameters */ 00030 00031 class CImpinjRequestedData; 00032 class CImpinjSubRegulatoryRegion; 00033 class CImpinjInventorySearchMode; 00034 class CImpinjFixedFrequencyList; 00035 class CImpinjReducedPowerFrequencyList; 00036 class CImpinjLowDutyCycle; 00037 class CImpinjHubVersions; 00038 class CImpinjDetailedVersion; 00039 class CImpinjFrequencyCapabilities; 00040 class CImpinjGPIDebounceConfiguration; 00041 class CImpinjReaderTemperature; 00042 class CImpinjLinkMonitorConfiguration; 00043 class CImpinjReportBufferConfiguration; 00044 class CImpinjAccessSpecConfiguration; 00045 class CImpinjBlockWriteWordCount; 00046 class CImpinjBlockPermalock; 00047 class CImpinjBlockPermalockOpSpecResult; 00048 class CImpinjGetBlockPermalockStatus; 00049 class CImpinjGetBlockPermalockStatusOpSpecResult; 00050 class CImpinjSetQTConfig; 00051 class CImpinjSetQTConfigOpSpecResult; 00052 class CImpinjGetQTConfig; 00053 class CImpinjGetQTConfigOpSpecResult; 00054 class CImpinjTagReportContentSelector; 00055 class CImpinjEnableSerializedTID; 00056 class CImpinjEnableRFPhaseAngle; 00057 class CImpinjEnablePeakRSSI; 00058 class CImpinjEnableGPSCoordinates; 00059 class CImpinjSerializedTID; 00060 class CImpinjRFPhaseAngle; 00061 class CImpinjPeakRSSI; 00062 class CImpinjGPSCoordinates; 00063 class CImpinjLoopSpec; 00064 class CImpinjGPSNMEASentences; 00065 class CImpinjGGASentence; 00066 class CImpinjRMCSentence; 00067 class CImpinjOpSpecRetryCount; 00068 class CImpinjAdvancedGPOConfiguration; 00069 class CImpinjEnableOptimizedRead; 00070 class CImpinjAccessSpecOrdering; 00071 class CImpinjEnableRFDopplerFrequency; 00072 class CImpinjRFDopplerFrequency; 00073 class CImpinjInventoryConfiguration; 00074 class CImpinjArrayVersion; 00075 class CImpinjxArrayCapabilities; 00076 class CImpinjTiltConfiguration; 00077 class CImpinjBeaconConfiguration; 00078 class CImpinjAntennaConfiguration; 00079 class CImpinjAntennaEventHysteresis; 00080 class CImpinjAntennaEventConfiguration; 00081 class CImpinjAntennaAttemptEvent; 00082 class CImpinjHubConfiguration; 00083 class CImpinjDiagnosticReport; 00084 class CImpinjPlacementConfiguration; 00085 class CImpinjLISpec; 00086 class CImpinjLocationConfig; 00087 class CImpinjC1G2LocationConfig; 00088 class CImpinjLocationReporting; 00089 class CImpinjLocationConfidence; 00090 class CImpinjLocationReportData; 00091 class CImpinjDISpec; 00092 class CImpinjDirectionSectors; 00093 class CImpinjDirectionConfig; 00094 class CImpinjDirectionUserTagPopulationLimit; 00095 class CImpinjC1G2DirectionConfig; 00096 class CImpinjExtendedTagInformation; 00097 class CImpinjDirectionReporting; 00098 class CImpinjDirectionReportData; 00099 class CImpinjDirectionDiagnosticData; 00100 class CImpinjxArrayDirectionCapabilities; 00101 class CImpinjIntelligentAntennaManagement; 00102 class CImpinjTransmitPower; 00103 class CImpinjPolarizationControl; 00104 class CImpinjAntennaCapabilities; 00105 class CImpinjAntennaPolarizationCapability; 00106 class CImpinjDisabledAntennas; 00107 class CImpinjTIDParity; 00108 class CImpinjMarginRead; 00109 class CImpinjMarginReadOpSpecResult; 00110 class CImpinjBLEVersion; 00111 00112 /* 00113 * Vendor descriptor declarations. 00114 */ 00115 00116 extern const CVendorDescriptor 00117 g_vdescImpinj; 00118 00119 00120 /* 00121 * Namespace descriptor declarations. 00122 */ 00123 00124 extern const CNamespaceDescriptor 00125 g_nsdescImpinj; 00126 00127 00128 /* 00129 * Enumeration definitions and declarations of 00130 * enumeration string tables. 00131 */ 00132 00133 00165 enum EImpinjRequestedDataType 00166 { 00167 00168 ImpinjRequestedDataType_All_Capabilities = 1000, 00169 ImpinjRequestedDataType_Impinj_Detailed_Version = 1001, 00170 ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002, 00171 ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003, 00172 ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004, 00173 ImpinjRequestedDataType_All_Configuration = 2000, 00174 ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001, 00175 ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003, 00176 ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004, 00177 ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005, 00178 ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006, 00179 ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007, 00180 ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008, 00181 ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009, 00182 ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010, 00183 ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011, 00184 ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012, 00185 ImpinjRequestedDataType_Impinj_Location_Configuration = 2013, 00186 ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014, 00187 ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015, 00188 ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017, 00189 ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018, 00190 }; 00191 00192 extern const SEnumTableEntry 00193 g_estImpinjRequestedDataType[]; 00194 00195 00229 enum EImpinjRegulatoryRegion 00230 { 00231 00232 ImpinjRegulatoryRegion_FCC_Part_15_247 = 0, 00233 ImpinjRegulatoryRegion_ETSI_EN_300_220 = 1, 00234 ImpinjRegulatoryRegion_ETSI_EN_302_208_With_LBT = 2, 00235 ImpinjRegulatoryRegion_Hong_Kong_920_925_MHz = 3, 00236 ImpinjRegulatoryRegion_Taiwan_922_928_MHz = 4, 00237 ImpinjRegulatoryRegion_ETSI_EN_302_208_v1_2_1 = 7, 00238 ImpinjRegulatoryRegion_Korea_917_921_MHz = 8, 00239 ImpinjRegulatoryRegion_Malaysia_919_923_MHz = 9, 00240 ImpinjRegulatoryRegion_China_920_925_MHz = 10, 00241 ImpinjRegulatoryRegion_South_Africa_915_919_MHz = 12, 00242 ImpinjRegulatoryRegion_Brazil_902_907_and_915_928_MHz = 13, 00243 ImpinjRegulatoryRegion_Thailand_920_925_MHz = 14, 00244 ImpinjRegulatoryRegion_Singapore_920_925_MHz = 15, 00245 ImpinjRegulatoryRegion_Australia_920_926_MHz = 16, 00246 ImpinjRegulatoryRegion_India_865_867_MHz = 17, 00247 ImpinjRegulatoryRegion_Uruguay_916_928_MHz = 18, 00248 ImpinjRegulatoryRegion_Vietnam_920_925_MHz = 19, 00249 ImpinjRegulatoryRegion_Israel_915_917_MHz = 20, 00250 ImpinjRegulatoryRegion_Philippines_918_920_MHz = 21, 00251 ImpinjRegulatoryRegion_Canada_Post = 22, 00252 ImpinjRegulatoryRegion_Indonesia_923_925_MHz = 23, 00253 ImpinjRegulatoryRegion_New_Zealand_921p5_928_MHz = 24, 00254 ImpinjRegulatoryRegion_Japan_916_921_MHz_Without_LBT = 25, 00255 ImpinjRegulatoryRegion_Latin_America_902_928_MHz = 26, 00256 ImpinjRegulatoryRegion_Peru_916_928_MHz = 27, 00257 ImpinjRegulatoryRegion_Bangladesh_925_927_MHz = 28, 00258 }; 00259 00260 extern const SEnumTableEntry 00261 g_estImpinjRegulatoryRegion[]; 00262 00263 00278 enum EImpinjInventorySearchType 00279 { 00280 00281 ImpinjInventorySearchType_Reader_Selected = 0, 00282 ImpinjInventorySearchType_Single_Target = 1, 00283 ImpinjInventorySearchType_Dual_Target = 2, 00284 ImpinjInventorySearchType_Single_Target_With_Suppression = 3, 00285 ImpinjInventorySearchType_No_Target = 4, 00286 ImpinjInventorySearchType_Single_Target_BtoA = 5, 00287 ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6, 00288 }; 00289 00290 extern const SEnumTableEntry 00291 g_estImpinjInventorySearchType[]; 00292 00293 00304 enum EImpinjFixedFrequencyMode 00305 { 00306 00307 ImpinjFixedFrequencyMode_Disabled = 0, 00308 ImpinjFixedFrequencyMode_Auto_Select = 1, 00309 ImpinjFixedFrequencyMode_Channel_List = 2, 00310 }; 00311 00312 extern const SEnumTableEntry 00313 g_estImpinjFixedFrequencyMode[]; 00314 00315 00325 enum EImpinjReducedPowerMode 00326 { 00327 00328 ImpinjReducedPowerMode_Disabled = 0, 00329 ImpinjReducedPowerMode_Enabled = 1, 00330 }; 00331 00332 extern const SEnumTableEntry 00333 g_estImpinjReducedPowerMode[]; 00334 00335 00345 enum EImpinjLowDutyCycleMode 00346 { 00347 00348 ImpinjLowDutyCycleMode_Disabled = 0, 00349 ImpinjLowDutyCycleMode_Enabled = 1, 00350 }; 00351 00352 extern const SEnumTableEntry 00353 g_estImpinjLowDutyCycleMode[]; 00354 00355 00365 enum EImpinjLinkMonitorMode 00366 { 00367 00368 ImpinjLinkMonitorMode_Disabled = 0, 00369 ImpinjLinkMonitorMode_Enabled = 1, 00370 }; 00371 00372 extern const SEnumTableEntry 00373 g_estImpinjLinkMonitorMode[]; 00374 00375 00385 enum EImpinjReportBufferMode 00386 { 00387 00388 ImpinjReportBufferMode_Normal = 0, 00389 ImpinjReportBufferMode_Low_Latency = 1, 00390 }; 00391 00392 extern const SEnumTableEntry 00393 g_estImpinjReportBufferMode[]; 00394 00395 00410 enum EImpinjBlockPermalockResultType 00411 { 00412 00413 ImpinjBlockPermalockResultType_Success = 0, 00414 ImpinjBlockPermalockResultType_Insufficient_Power = 1, 00415 ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2, 00416 ImpinjBlockPermalockResultType_No_Response_From_Tag = 3, 00417 ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4, 00418 ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5, 00419 ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6, 00420 }; 00421 00422 extern const SEnumTableEntry 00423 g_estImpinjBlockPermalockResultType[]; 00424 00425 00439 enum EImpinjGetBlockPermalockStatusResultType 00440 { 00441 00442 ImpinjGetBlockPermalockStatusResultType_Success = 0, 00443 ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1, 00444 ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2, 00445 ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3, 00446 ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4, 00447 ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5, 00448 }; 00449 00450 extern const SEnumTableEntry 00451 g_estImpinjGetBlockPermalockStatusResultType[]; 00452 00453 00464 enum EImpinjQTDataProfile 00465 { 00466 00467 ImpinjQTDataProfile_Unknown = 0, 00468 ImpinjQTDataProfile_Private = 1, 00469 ImpinjQTDataProfile_Public = 2, 00470 }; 00471 00472 extern const SEnumTableEntry 00473 g_estImpinjQTDataProfile[]; 00474 00475 00486 enum EImpinjQTAccessRange 00487 { 00488 00489 ImpinjQTAccessRange_Unknown = 0, 00490 ImpinjQTAccessRange_Normal_Range = 1, 00491 ImpinjQTAccessRange_Short_Range = 2, 00492 }; 00493 00494 extern const SEnumTableEntry 00495 g_estImpinjQTAccessRange[]; 00496 00497 00508 enum EImpinjQTPersistence 00509 { 00510 00511 ImpinjQTPersistence_Unknown = 0, 00512 ImpinjQTPersistence_Temporary = 1, 00513 ImpinjQTPersistence_Permanent = 2, 00514 }; 00515 00516 extern const SEnumTableEntry 00517 g_estImpinjQTPersistence[]; 00518 00519 00533 enum EImpinjSetQTConfigResultType 00534 { 00535 00536 ImpinjSetQTConfigResultType_Success = 0, 00537 ImpinjSetQTConfigResultType_Insufficient_Power = 1, 00538 ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2, 00539 ImpinjSetQTConfigResultType_No_Response_From_Tag = 3, 00540 ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4, 00541 ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5, 00542 }; 00543 00544 extern const SEnumTableEntry 00545 g_estImpinjSetQTConfigResultType[]; 00546 00547 00560 enum EImpinjGetQTConfigResultType 00561 { 00562 00563 ImpinjGetQTConfigResultType_Success = 0, 00564 ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1, 00565 ImpinjGetQTConfigResultType_No_Response_From_Tag = 2, 00566 ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3, 00567 ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4, 00568 }; 00569 00570 extern const SEnumTableEntry 00571 g_estImpinjGetQTConfigResultType[]; 00572 00573 00583 enum EImpinjSerializedTIDMode 00584 { 00585 00586 ImpinjSerializedTIDMode_Disabled = 0, 00587 ImpinjSerializedTIDMode_Enabled = 1, 00588 }; 00589 00590 extern const SEnumTableEntry 00591 g_estImpinjSerializedTIDMode[]; 00592 00593 00603 enum EImpinjRFPhaseAngleMode 00604 { 00605 00606 ImpinjRFPhaseAngleMode_Disabled = 0, 00607 ImpinjRFPhaseAngleMode_Enabled = 1, 00608 }; 00609 00610 extern const SEnumTableEntry 00611 g_estImpinjRFPhaseAngleMode[]; 00612 00613 00623 enum EImpinjPeakRSSIMode 00624 { 00625 00626 ImpinjPeakRSSIMode_Disabled = 0, 00627 ImpinjPeakRSSIMode_Enabled = 1, 00628 }; 00629 00630 extern const SEnumTableEntry 00631 g_estImpinjPeakRSSIMode[]; 00632 00633 00643 enum EImpinjGPSCoordinatesMode 00644 { 00645 00646 ImpinjGPSCoordinatesMode_Disabled = 0, 00647 ImpinjGPSCoordinatesMode_Enabled = 1, 00648 }; 00649 00650 extern const SEnumTableEntry 00651 g_estImpinjGPSCoordinatesMode[]; 00652 00653 00668 enum EImpinjAdvancedGPOMode 00669 { 00670 00671 ImpinjAdvancedGPOMode_Normal = 0, 00672 ImpinjAdvancedGPOMode_Pulsed = 1, 00673 ImpinjAdvancedGPOMode_Reader_Operational_Status = 2, 00674 ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3, 00675 ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4, 00676 ImpinjAdvancedGPOMode_Network_Connection_Status = 5, 00677 ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6, 00678 }; 00679 00680 extern const SEnumTableEntry 00681 g_estImpinjAdvancedGPOMode[]; 00682 00683 00693 enum EImpinjOptimizedReadMode 00694 { 00695 00696 ImpinjOptimizedReadMode_Disabled = 0, 00697 ImpinjOptimizedReadMode_Enabled = 1, 00698 }; 00699 00700 extern const SEnumTableEntry 00701 g_estImpinjOptimizedReadMode[]; 00702 00703 00713 enum EImpinjAccessSpecOrderingMode 00714 { 00715 00716 ImpinjAccessSpecOrderingMode_FIFO = 0, 00717 ImpinjAccessSpecOrderingMode_Ascending = 1, 00718 }; 00719 00720 extern const SEnumTableEntry 00721 g_estImpinjAccessSpecOrderingMode[]; 00722 00723 00733 enum EImpinjRFDopplerFrequencyMode 00734 { 00735 00736 ImpinjRFDopplerFrequencyMode_Disabled = 0, 00737 ImpinjRFDopplerFrequencyMode_Enabled = 1, 00738 }; 00739 00740 extern const SEnumTableEntry 00741 g_estImpinjRFDopplerFrequencyMode[]; 00742 00743 00754 enum EImpinjHubConnectedType 00755 { 00756 00757 ImpinjHubConnectedType_Unknown = 0, 00758 ImpinjHubConnectedType_Disconnected = 1, 00759 ImpinjHubConnectedType_Connected = 2, 00760 }; 00761 00762 extern const SEnumTableEntry 00763 g_estImpinjHubConnectedType[]; 00764 00765 00782 enum EImpinjHubFaultType 00783 { 00784 00785 ImpinjHubFaultType_No_Fault = 0, 00786 ImpinjHubFaultType_RF_Power = 1, 00787 ImpinjHubFaultType_RF_Power_On_Hub_1 = 2, 00788 ImpinjHubFaultType_RF_Power_On_Hub_2 = 3, 00789 ImpinjHubFaultType_RF_Power_On_Hub_3 = 4, 00790 ImpinjHubFaultType_RF_Power_On_Hub_4 = 5, 00791 ImpinjHubFaultType_No_Init = 6, 00792 ImpinjHubFaultType_Serial_Overflow = 7, 00793 ImpinjHubFaultType_Disconnected = 8, 00794 }; 00795 00796 extern const SEnumTableEntry 00797 g_estImpinjHubFaultType[]; 00798 00799 00810 enum EImpinjLocationReportType 00811 { 00812 00813 ImpinjLocationReportType_Entry = 0, 00814 ImpinjLocationReportType_Update = 1, 00815 ImpinjLocationReportType_Exit = 2, 00816 }; 00817 00818 extern const SEnumTableEntry 00819 g_estImpinjLocationReportType[]; 00820 00821 00865 enum EImpinjDirectionFieldOfView 00866 { 00867 00868 ImpinjDirectionFieldOfView_ReaderSelected = 0, 00869 ImpinjDirectionFieldOfView_Wide = 1, 00870 ImpinjDirectionFieldOfView_Narrow = 2, 00871 }; 00872 00873 extern const SEnumTableEntry 00874 g_estImpinjDirectionFieldOfView[]; 00875 00876 00911 enum EImpinjDirectionRFMode 00912 { 00913 00914 ImpinjDirectionRFMode_HighSensitivity = 0, 00915 ImpinjDirectionRFMode_HighPerformance = 1, 00916 }; 00917 00918 extern const SEnumTableEntry 00919 g_estImpinjDirectionRFMode[]; 00920 00921 00971 enum EImpinjDirectionDiagnosticReportLevel 00972 { 00973 00974 ImpinjDirectionDiagnosticReportLevel_Off = 0, 00975 ImpinjDirectionDiagnosticReportLevel_Basic = 1, 00976 ImpinjDirectionDiagnosticReportLevel_Extended = 2, 00977 ImpinjDirectionDiagnosticReportLevel_Debug = 3, 00978 }; 00979 00980 extern const SEnumTableEntry 00981 g_estImpinjDirectionDiagnosticReportLevel[]; 00982 00983 01022 enum EImpinjDirectionReportType 01023 { 01024 01025 ImpinjDirectionReportType_Entry = 0, 01026 ImpinjDirectionReportType_Update = 1, 01027 ImpinjDirectionReportType_Exit = 2, 01028 }; 01029 01030 extern const SEnumTableEntry 01031 g_estImpinjDirectionReportType[]; 01032 01033 01072 enum EImpinjDirectionTagPopulationStatus 01073 { 01074 01075 ImpinjDirectionTagPopulationStatus_OK = 0, 01076 ImpinjDirectionTagPopulationStatus_UserOverflow = 1, 01077 ImpinjDirectionTagPopulationStatus_SystemOverflow = 2, 01078 }; 01079 01080 extern const SEnumTableEntry 01081 g_estImpinjDirectionTagPopulationStatus[]; 01082 01083 01093 enum EImpinjIntelligentAntennaMode 01094 { 01095 01096 ImpinjIntelligentAntennaMode_Disabled = 0, 01097 ImpinjIntelligentAntennaMode_Enabled = 1, 01098 }; 01099 01100 extern const SEnumTableEntry 01101 g_estImpinjIntelligentAntennaMode[]; 01102 01103 01115 enum EImpinjAntennaPolarizationType 01116 { 01117 01118 ImpinjAntennaPolarizationType_LinearHorizontal = 0, 01119 ImpinjAntennaPolarizationType_LinearVertical = 1, 01120 ImpinjAntennaPolarizationType_CircularRight = 2, 01121 ImpinjAntennaPolarizationType_CircularLeft = 3, 01122 }; 01123 01124 extern const SEnumTableEntry 01125 g_estImpinjAntennaPolarizationType[]; 01126 01127 01144 enum EImpinjMarginReadResultType 01145 { 01146 01147 ImpinjMarginReadResultType_Success = 0, 01148 ImpinjMarginReadResultType_Failure = 1, 01149 ImpinjMarginReadResultType_Insufficient_Power = 2, 01150 ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3, 01151 ImpinjMarginReadResultType_No_Response_From_Tag = 4, 01152 ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5, 01153 ImpinjMarginReadResultType_Incorrect_Password_Error = 6, 01154 ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7, 01155 ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8, 01156 }; 01157 01158 extern const SEnumTableEntry 01159 g_estImpinjMarginReadResultType[]; 01160 01161 01167 01191 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage 01192 { 01193 public: 01194 CIMPINJ_ENABLE_EXTENSIONS (void); 01195 ~CIMPINJ_ENABLE_EXTENSIONS (void); 01196 01199 01200 static const CFieldDescriptor * const 01201 s_apFieldDescriptorTable[]; 01202 01203 static const CTypeDescriptor 01204 s_typeDescriptor; 01205 01206 void 01207 decodeFields ( 01208 CDecoderStream * pDecoderStream); 01209 01210 void 01211 assimilateSubParameters ( 01212 CErrorDetails * pError); 01213 01214 void 01215 encode ( 01216 CEncoderStream * pEncoderStream) const; 01217 01218 01219 01220 static CElement * 01221 s_construct (void); 01222 01223 static void 01224 s_decodeFields ( 01225 CDecoderStream * pDecoderStream, 01226 CElement * pElement); 01228 01229 01230 01231 protected: 01232 std::list<CParameter *> m_listCustom; 01233 01234 public: 01236 inline std::list<CParameter *>::iterator 01237 beginCustom (void) 01238 { 01239 return m_listCustom.begin(); 01240 } 01241 01243 inline std::list<CParameter *>::iterator 01244 endCustom (void) 01245 { 01246 return m_listCustom.end(); 01247 } 01248 01250 inline void 01251 clearCustom (void) 01252 { 01253 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01254 } 01255 01257 inline int 01258 countCustom (void) 01259 { 01260 return (int) (m_listCustom.size()); 01261 } 01262 01263 EResultCode 01265 addCustom ( 01266 CParameter * pValue); 01267 01268 01269 }; 01270 01271 01295 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage 01296 { 01297 public: 01298 CIMPINJ_ENABLE_EXTENSIONS_RESPONSE (void); 01299 ~CIMPINJ_ENABLE_EXTENSIONS_RESPONSE (void); 01300 01303 01304 static const CFieldDescriptor * const 01305 s_apFieldDescriptorTable[]; 01306 01307 static const CTypeDescriptor 01308 s_typeDescriptor; 01309 01310 void 01311 decodeFields ( 01312 CDecoderStream * pDecoderStream); 01313 01314 void 01315 assimilateSubParameters ( 01316 CErrorDetails * pError); 01317 01318 void 01319 encode ( 01320 CEncoderStream * pEncoderStream) const; 01321 01322 01323 01324 static CElement * 01325 s_construct (void); 01326 01327 static void 01328 s_decodeFields ( 01329 CDecoderStream * pDecoderStream, 01330 CElement * pElement); 01332 01333 01334 01335 protected: 01336 CLLRPStatus * m_pLLRPStatus; 01337 01338 public: 01340 inline CLLRPStatus * 01341 getLLRPStatus (void) 01342 { 01343 return m_pLLRPStatus; 01344 } 01345 01347 EResultCode 01348 setLLRPStatus ( 01349 CLLRPStatus * pValue); 01350 01351 01352 protected: 01353 std::list<CParameter *> m_listCustom; 01354 01355 public: 01357 inline std::list<CParameter *>::iterator 01358 beginCustom (void) 01359 { 01360 return m_listCustom.begin(); 01361 } 01362 01364 inline std::list<CParameter *>::iterator 01365 endCustom (void) 01366 { 01367 return m_listCustom.end(); 01368 } 01369 01371 inline void 01372 clearCustom (void) 01373 { 01374 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01375 } 01376 01378 inline int 01379 countCustom (void) 01380 { 01381 return (int) (m_listCustom.size()); 01382 } 01383 01384 EResultCode 01386 addCustom ( 01387 CParameter * pValue); 01388 01389 01390 }; 01391 01392 01426 class CIMPINJ_SAVE_SETTINGS : public CMessage 01427 { 01428 public: 01429 CIMPINJ_SAVE_SETTINGS (void); 01430 ~CIMPINJ_SAVE_SETTINGS (void); 01431 01434 01435 static const CFieldDescriptor * const 01436 s_apFieldDescriptorTable[]; 01437 01438 static const CTypeDescriptor 01439 s_typeDescriptor; 01440 01441 void 01442 decodeFields ( 01443 CDecoderStream * pDecoderStream); 01444 01445 void 01446 assimilateSubParameters ( 01447 CErrorDetails * pError); 01448 01449 void 01450 encode ( 01451 CEncoderStream * pEncoderStream) const; 01452 01453 01454 01455 static CElement * 01456 s_construct (void); 01457 01458 static void 01459 s_decodeFields ( 01460 CDecoderStream * pDecoderStream, 01461 CElement * pElement); 01463 01464 01465 protected: 01466 llrp_u1_t m_SaveConfiguration; 01467 01470 public: 01471 static const CFieldDescriptor 01472 s_fdSaveConfiguration; 01474 01476 inline llrp_u1_t 01477 getSaveConfiguration (void) 01478 { 01479 return m_SaveConfiguration; 01480 } 01481 01483 inline void 01484 setSaveConfiguration ( 01485 llrp_u1_t value) 01486 { 01487 m_SaveConfiguration = value; 01488 } 01489 01490 01491 01492 protected: 01493 std::list<CParameter *> m_listCustom; 01494 01495 public: 01497 inline std::list<CParameter *>::iterator 01498 beginCustom (void) 01499 { 01500 return m_listCustom.begin(); 01501 } 01502 01504 inline std::list<CParameter *>::iterator 01505 endCustom (void) 01506 { 01507 return m_listCustom.end(); 01508 } 01509 01511 inline void 01512 clearCustom (void) 01513 { 01514 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01515 } 01516 01518 inline int 01519 countCustom (void) 01520 { 01521 return (int) (m_listCustom.size()); 01522 } 01523 01524 EResultCode 01526 addCustom ( 01527 CParameter * pValue); 01528 01529 01530 }; 01531 01532 01556 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage 01557 { 01558 public: 01559 CIMPINJ_SAVE_SETTINGS_RESPONSE (void); 01560 ~CIMPINJ_SAVE_SETTINGS_RESPONSE (void); 01561 01564 01565 static const CFieldDescriptor * const 01566 s_apFieldDescriptorTable[]; 01567 01568 static const CTypeDescriptor 01569 s_typeDescriptor; 01570 01571 void 01572 decodeFields ( 01573 CDecoderStream * pDecoderStream); 01574 01575 void 01576 assimilateSubParameters ( 01577 CErrorDetails * pError); 01578 01579 void 01580 encode ( 01581 CEncoderStream * pEncoderStream) const; 01582 01583 01584 01585 static CElement * 01586 s_construct (void); 01587 01588 static void 01589 s_decodeFields ( 01590 CDecoderStream * pDecoderStream, 01591 CElement * pElement); 01593 01594 01595 01596 protected: 01597 CLLRPStatus * m_pLLRPStatus; 01598 01599 public: 01601 inline CLLRPStatus * 01602 getLLRPStatus (void) 01603 { 01604 return m_pLLRPStatus; 01605 } 01606 01608 EResultCode 01609 setLLRPStatus ( 01610 CLLRPStatus * pValue); 01611 01612 01613 protected: 01614 std::list<CParameter *> m_listCustom; 01615 01616 public: 01618 inline std::list<CParameter *>::iterator 01619 beginCustom (void) 01620 { 01621 return m_listCustom.begin(); 01622 } 01623 01625 inline std::list<CParameter *>::iterator 01626 endCustom (void) 01627 { 01628 return m_listCustom.end(); 01629 } 01630 01632 inline void 01633 clearCustom (void) 01634 { 01635 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01636 } 01637 01639 inline int 01640 countCustom (void) 01641 { 01642 return (int) (m_listCustom.size()); 01643 } 01644 01645 EResultCode 01647 addCustom ( 01648 CParameter * pValue); 01649 01650 01651 }; 01652 01653 01661 01684 class CImpinjRequestedData : public CParameter 01685 { 01686 public: 01687 CImpinjRequestedData (void); 01688 ~CImpinjRequestedData (void); 01689 01692 01693 static const CFieldDescriptor * const 01694 s_apFieldDescriptorTable[]; 01695 01696 static const CTypeDescriptor 01697 s_typeDescriptor; 01698 01699 void 01700 decodeFields ( 01701 CDecoderStream * pDecoderStream); 01702 01703 void 01704 assimilateSubParameters ( 01705 CErrorDetails * pError); 01706 01707 void 01708 encode ( 01709 CEncoderStream * pEncoderStream) const; 01710 01711 01712 llrp_bool_t 01713 isAllowedIn ( 01714 const CTypeDescriptor * pEnclosingElementType) const; 01715 01716 01717 static CElement * 01718 s_construct (void); 01719 01720 static void 01721 s_decodeFields ( 01722 CDecoderStream * pDecoderStream, 01723 CElement * pElement); 01725 01726 01727 protected: 01728 EImpinjRequestedDataType m_eRequestedData; 01729 01732 public: 01733 static const CFieldDescriptor 01734 s_fdRequestedData; 01736 01738 inline EImpinjRequestedDataType 01739 getRequestedData (void) 01740 { 01741 return m_eRequestedData; 01742 } 01743 01745 inline void 01746 setRequestedData ( 01747 EImpinjRequestedDataType value) 01748 { 01749 m_eRequestedData = value; 01750 } 01751 01752 01753 01754 protected: 01755 std::list<CParameter *> m_listCustom; 01756 01757 public: 01759 inline std::list<CParameter *>::iterator 01760 beginCustom (void) 01761 { 01762 return m_listCustom.begin(); 01763 } 01764 01766 inline std::list<CParameter *>::iterator 01767 endCustom (void) 01768 { 01769 return m_listCustom.end(); 01770 } 01771 01773 inline void 01774 clearCustom (void) 01775 { 01776 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01777 } 01778 01780 inline int 01781 countCustom (void) 01782 { 01783 return (int) (m_listCustom.size()); 01784 } 01785 01786 EResultCode 01788 addCustom ( 01789 CParameter * pValue); 01790 01791 01792 }; 01793 01794 01823 class CImpinjSubRegulatoryRegion : public CParameter 01824 { 01825 public: 01826 CImpinjSubRegulatoryRegion (void); 01827 ~CImpinjSubRegulatoryRegion (void); 01828 01831 01832 static const CFieldDescriptor * const 01833 s_apFieldDescriptorTable[]; 01834 01835 static const CTypeDescriptor 01836 s_typeDescriptor; 01837 01838 void 01839 decodeFields ( 01840 CDecoderStream * pDecoderStream); 01841 01842 void 01843 assimilateSubParameters ( 01844 CErrorDetails * pError); 01845 01846 void 01847 encode ( 01848 CEncoderStream * pEncoderStream) const; 01849 01850 01851 llrp_bool_t 01852 isAllowedIn ( 01853 const CTypeDescriptor * pEnclosingElementType) const; 01854 01855 01856 static CElement * 01857 s_construct (void); 01858 01859 static void 01860 s_decodeFields ( 01861 CDecoderStream * pDecoderStream, 01862 CElement * pElement); 01864 01865 01866 protected: 01867 EImpinjRegulatoryRegion m_eRegulatoryRegion; 01868 01871 public: 01872 static const CFieldDescriptor 01873 s_fdRegulatoryRegion; 01875 01877 inline EImpinjRegulatoryRegion 01878 getRegulatoryRegion (void) 01879 { 01880 return m_eRegulatoryRegion; 01881 } 01882 01884 inline void 01885 setRegulatoryRegion ( 01886 EImpinjRegulatoryRegion value) 01887 { 01888 m_eRegulatoryRegion = value; 01889 } 01890 01891 01892 01893 protected: 01894 std::list<CParameter *> m_listCustom; 01895 01896 public: 01898 inline std::list<CParameter *>::iterator 01899 beginCustom (void) 01900 { 01901 return m_listCustom.begin(); 01902 } 01903 01905 inline std::list<CParameter *>::iterator 01906 endCustom (void) 01907 { 01908 return m_listCustom.end(); 01909 } 01910 01912 inline void 01913 clearCustom (void) 01914 { 01915 clearSubParameterList ((tListOfParameters *) &m_listCustom); 01916 } 01917 01919 inline int 01920 countCustom (void) 01921 { 01922 return (int) (m_listCustom.size()); 01923 } 01924 01925 EResultCode 01927 addCustom ( 01928 CParameter * pValue); 01929 01930 01931 }; 01932 01933 01958 class CImpinjInventorySearchMode : public CParameter 01959 { 01960 public: 01961 CImpinjInventorySearchMode (void); 01962 ~CImpinjInventorySearchMode (void); 01963 01966 01967 static const CFieldDescriptor * const 01968 s_apFieldDescriptorTable[]; 01969 01970 static const CTypeDescriptor 01971 s_typeDescriptor; 01972 01973 void 01974 decodeFields ( 01975 CDecoderStream * pDecoderStream); 01976 01977 void 01978 assimilateSubParameters ( 01979 CErrorDetails * pError); 01980 01981 void 01982 encode ( 01983 CEncoderStream * pEncoderStream) const; 01984 01985 01986 llrp_bool_t 01987 isAllowedIn ( 01988 const CTypeDescriptor * pEnclosingElementType) const; 01989 01990 01991 static CElement * 01992 s_construct (void); 01993 01994 static void 01995 s_decodeFields ( 01996 CDecoderStream * pDecoderStream, 01997 CElement * pElement); 01999 02000 02001 protected: 02002 EImpinjInventorySearchType m_eInventorySearchMode; 02003 02006 public: 02007 static const CFieldDescriptor 02008 s_fdInventorySearchMode; 02010 02012 inline EImpinjInventorySearchType 02013 getInventorySearchMode (void) 02014 { 02015 return m_eInventorySearchMode; 02016 } 02017 02019 inline void 02020 setInventorySearchMode ( 02021 EImpinjInventorySearchType value) 02022 { 02023 m_eInventorySearchMode = value; 02024 } 02025 02026 02027 02028 protected: 02029 std::list<CParameter *> m_listCustom; 02030 02031 public: 02033 inline std::list<CParameter *>::iterator 02034 beginCustom (void) 02035 { 02036 return m_listCustom.begin(); 02037 } 02038 02040 inline std::list<CParameter *>::iterator 02041 endCustom (void) 02042 { 02043 return m_listCustom.end(); 02044 } 02045 02047 inline void 02048 clearCustom (void) 02049 { 02050 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02051 } 02052 02054 inline int 02055 countCustom (void) 02056 { 02057 return (int) (m_listCustom.size()); 02058 } 02059 02060 EResultCode 02062 addCustom ( 02063 CParameter * pValue); 02064 02065 02066 }; 02067 02068 02098 class CImpinjFixedFrequencyList : public CParameter 02099 { 02100 public: 02101 CImpinjFixedFrequencyList (void); 02102 ~CImpinjFixedFrequencyList (void); 02103 02106 02107 static const CFieldDescriptor * const 02108 s_apFieldDescriptorTable[]; 02109 02110 static const CTypeDescriptor 02111 s_typeDescriptor; 02112 02113 void 02114 decodeFields ( 02115 CDecoderStream * pDecoderStream); 02116 02117 void 02118 assimilateSubParameters ( 02119 CErrorDetails * pError); 02120 02121 void 02122 encode ( 02123 CEncoderStream * pEncoderStream) const; 02124 02125 02126 llrp_bool_t 02127 isAllowedIn ( 02128 const CTypeDescriptor * pEnclosingElementType) const; 02129 02130 02131 static CElement * 02132 s_construct (void); 02133 02134 static void 02135 s_decodeFields ( 02136 CDecoderStream * pDecoderStream, 02137 CElement * pElement); 02139 02140 02141 protected: 02142 EImpinjFixedFrequencyMode m_eFixedFrequencyMode; 02143 02146 public: 02147 static const CFieldDescriptor 02148 s_fdFixedFrequencyMode; 02150 02152 inline EImpinjFixedFrequencyMode 02153 getFixedFrequencyMode (void) 02154 { 02155 return m_eFixedFrequencyMode; 02156 } 02157 02159 inline void 02160 setFixedFrequencyMode ( 02161 EImpinjFixedFrequencyMode value) 02162 { 02163 m_eFixedFrequencyMode = value; 02164 } 02165 02166 02167 protected: 02168 llrp_u16v_t m_ChannelList; 02169 02172 public: 02173 static const CFieldDescriptor 02174 s_fdChannelList; 02176 02178 inline llrp_u16v_t 02179 getChannelList (void) 02180 { 02181 return m_ChannelList; 02182 } 02183 02185 inline void 02186 setChannelList ( 02187 llrp_u16v_t value) 02188 { 02189 m_ChannelList = value; 02190 } 02191 02192 02193 02194 protected: 02195 std::list<CParameter *> m_listCustom; 02196 02197 public: 02199 inline std::list<CParameter *>::iterator 02200 beginCustom (void) 02201 { 02202 return m_listCustom.begin(); 02203 } 02204 02206 inline std::list<CParameter *>::iterator 02207 endCustom (void) 02208 { 02209 return m_listCustom.end(); 02210 } 02211 02213 inline void 02214 clearCustom (void) 02215 { 02216 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02217 } 02218 02220 inline int 02221 countCustom (void) 02222 { 02223 return (int) (m_listCustom.size()); 02224 } 02225 02226 EResultCode 02228 addCustom ( 02229 CParameter * pValue); 02230 02231 02232 }; 02233 02234 02264 class CImpinjReducedPowerFrequencyList : public CParameter 02265 { 02266 public: 02267 CImpinjReducedPowerFrequencyList (void); 02268 ~CImpinjReducedPowerFrequencyList (void); 02269 02272 02273 static const CFieldDescriptor * const 02274 s_apFieldDescriptorTable[]; 02275 02276 static const CTypeDescriptor 02277 s_typeDescriptor; 02278 02279 void 02280 decodeFields ( 02281 CDecoderStream * pDecoderStream); 02282 02283 void 02284 assimilateSubParameters ( 02285 CErrorDetails * pError); 02286 02287 void 02288 encode ( 02289 CEncoderStream * pEncoderStream) const; 02290 02291 02292 llrp_bool_t 02293 isAllowedIn ( 02294 const CTypeDescriptor * pEnclosingElementType) const; 02295 02296 02297 static CElement * 02298 s_construct (void); 02299 02300 static void 02301 s_decodeFields ( 02302 CDecoderStream * pDecoderStream, 02303 CElement * pElement); 02305 02306 02307 protected: 02308 EImpinjReducedPowerMode m_eReducedPowerMode; 02309 02312 public: 02313 static const CFieldDescriptor 02314 s_fdReducedPowerMode; 02316 02318 inline EImpinjReducedPowerMode 02319 getReducedPowerMode (void) 02320 { 02321 return m_eReducedPowerMode; 02322 } 02323 02325 inline void 02326 setReducedPowerMode ( 02327 EImpinjReducedPowerMode value) 02328 { 02329 m_eReducedPowerMode = value; 02330 } 02331 02332 02333 protected: 02334 llrp_u16v_t m_ChannelList; 02335 02338 public: 02339 static const CFieldDescriptor 02340 s_fdChannelList; 02342 02344 inline llrp_u16v_t 02345 getChannelList (void) 02346 { 02347 return m_ChannelList; 02348 } 02349 02351 inline void 02352 setChannelList ( 02353 llrp_u16v_t value) 02354 { 02355 m_ChannelList = value; 02356 } 02357 02358 02359 02360 protected: 02361 std::list<CParameter *> m_listCustom; 02362 02363 public: 02365 inline std::list<CParameter *>::iterator 02366 beginCustom (void) 02367 { 02368 return m_listCustom.begin(); 02369 } 02370 02372 inline std::list<CParameter *>::iterator 02373 endCustom (void) 02374 { 02375 return m_listCustom.end(); 02376 } 02377 02379 inline void 02380 clearCustom (void) 02381 { 02382 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02383 } 02384 02386 inline int 02387 countCustom (void) 02388 { 02389 return (int) (m_listCustom.size()); 02390 } 02391 02392 EResultCode 02394 addCustom ( 02395 CParameter * pValue); 02396 02397 02398 }; 02399 02400 02430 class CImpinjLowDutyCycle : public CParameter 02431 { 02432 public: 02433 CImpinjLowDutyCycle (void); 02434 ~CImpinjLowDutyCycle (void); 02435 02438 02439 static const CFieldDescriptor * const 02440 s_apFieldDescriptorTable[]; 02441 02442 static const CTypeDescriptor 02443 s_typeDescriptor; 02444 02445 void 02446 decodeFields ( 02447 CDecoderStream * pDecoderStream); 02448 02449 void 02450 assimilateSubParameters ( 02451 CErrorDetails * pError); 02452 02453 void 02454 encode ( 02455 CEncoderStream * pEncoderStream) const; 02456 02457 02458 llrp_bool_t 02459 isAllowedIn ( 02460 const CTypeDescriptor * pEnclosingElementType) const; 02461 02462 02463 static CElement * 02464 s_construct (void); 02465 02466 static void 02467 s_decodeFields ( 02468 CDecoderStream * pDecoderStream, 02469 CElement * pElement); 02471 02472 02473 protected: 02474 EImpinjLowDutyCycleMode m_eLowDutyCycleMode; 02475 02478 public: 02479 static const CFieldDescriptor 02480 s_fdLowDutyCycleMode; 02482 02484 inline EImpinjLowDutyCycleMode 02485 getLowDutyCycleMode (void) 02486 { 02487 return m_eLowDutyCycleMode; 02488 } 02489 02491 inline void 02492 setLowDutyCycleMode ( 02493 EImpinjLowDutyCycleMode value) 02494 { 02495 m_eLowDutyCycleMode = value; 02496 } 02497 02498 02499 protected: 02500 llrp_u16_t m_EmptyFieldTimeout; 02501 02504 public: 02505 static const CFieldDescriptor 02506 s_fdEmptyFieldTimeout; 02508 02510 inline llrp_u16_t 02511 getEmptyFieldTimeout (void) 02512 { 02513 return m_EmptyFieldTimeout; 02514 } 02515 02517 inline void 02518 setEmptyFieldTimeout ( 02519 llrp_u16_t value) 02520 { 02521 m_EmptyFieldTimeout = value; 02522 } 02523 02524 02525 protected: 02526 llrp_u16_t m_FieldPingInterval; 02527 02530 public: 02531 static const CFieldDescriptor 02532 s_fdFieldPingInterval; 02534 02536 inline llrp_u16_t 02537 getFieldPingInterval (void) 02538 { 02539 return m_FieldPingInterval; 02540 } 02541 02543 inline void 02544 setFieldPingInterval ( 02545 llrp_u16_t value) 02546 { 02547 m_FieldPingInterval = value; 02548 } 02549 02550 02551 02552 protected: 02553 std::list<CParameter *> m_listCustom; 02554 02555 public: 02557 inline std::list<CParameter *>::iterator 02558 beginCustom (void) 02559 { 02560 return m_listCustom.begin(); 02561 } 02562 02564 inline std::list<CParameter *>::iterator 02565 endCustom (void) 02566 { 02567 return m_listCustom.end(); 02568 } 02569 02571 inline void 02572 clearCustom (void) 02573 { 02574 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02575 } 02576 02578 inline int 02579 countCustom (void) 02580 { 02581 return (int) (m_listCustom.size()); 02582 } 02583 02584 EResultCode 02586 addCustom ( 02587 CParameter * pValue); 02588 02589 02590 }; 02591 02592 02617 class CImpinjHubVersions : public CParameter 02618 { 02619 public: 02620 CImpinjHubVersions (void); 02621 ~CImpinjHubVersions (void); 02622 02625 02626 static const CFieldDescriptor * const 02627 s_apFieldDescriptorTable[]; 02628 02629 static const CTypeDescriptor 02630 s_typeDescriptor; 02631 02632 void 02633 decodeFields ( 02634 CDecoderStream * pDecoderStream); 02635 02636 void 02637 assimilateSubParameters ( 02638 CErrorDetails * pError); 02639 02640 void 02641 encode ( 02642 CEncoderStream * pEncoderStream) const; 02643 02644 02645 llrp_bool_t 02646 isAllowedIn ( 02647 const CTypeDescriptor * pEnclosingElementType) const; 02648 02649 02650 static CElement * 02651 s_construct (void); 02652 02653 static void 02654 s_decodeFields ( 02655 CDecoderStream * pDecoderStream, 02656 CElement * pElement); 02658 02659 02660 02661 protected: 02662 std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion; 02663 02664 public: 02666 inline std::list<CImpinjArrayVersion *>::iterator 02667 beginImpinjArrayVersion (void) 02668 { 02669 return m_listImpinjArrayVersion.begin(); 02670 } 02671 02673 inline std::list<CImpinjArrayVersion *>::iterator 02674 endImpinjArrayVersion (void) 02675 { 02676 return m_listImpinjArrayVersion.end(); 02677 } 02678 02680 inline void 02681 clearImpinjArrayVersion (void) 02682 { 02683 clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion); 02684 } 02685 02687 inline int 02688 countImpinjArrayVersion (void) 02689 { 02690 return (int) (m_listImpinjArrayVersion.size()); 02691 } 02692 02693 EResultCode 02695 addImpinjArrayVersion ( 02696 CImpinjArrayVersion * pValue); 02697 02698 02699 protected: 02700 std::list<CParameter *> m_listCustom; 02701 02702 public: 02704 inline std::list<CParameter *>::iterator 02705 beginCustom (void) 02706 { 02707 return m_listCustom.begin(); 02708 } 02709 02711 inline std::list<CParameter *>::iterator 02712 endCustom (void) 02713 { 02714 return m_listCustom.end(); 02715 } 02716 02718 inline void 02719 clearCustom (void) 02720 { 02721 clearSubParameterList ((tListOfParameters *) &m_listCustom); 02722 } 02723 02725 inline int 02726 countCustom (void) 02727 { 02728 return (int) (m_listCustom.size()); 02729 } 02730 02731 EResultCode 02733 addCustom ( 02734 CParameter * pValue); 02735 02736 02737 }; 02738 02739 02772 class CImpinjDetailedVersion : public CParameter 02773 { 02774 public: 02775 CImpinjDetailedVersion (void); 02776 ~CImpinjDetailedVersion (void); 02777 02780 02781 static const CFieldDescriptor * const 02782 s_apFieldDescriptorTable[]; 02783 02784 static const CTypeDescriptor 02785 s_typeDescriptor; 02786 02787 void 02788 decodeFields ( 02789 CDecoderStream * pDecoderStream); 02790 02791 void 02792 assimilateSubParameters ( 02793 CErrorDetails * pError); 02794 02795 void 02796 encode ( 02797 CEncoderStream * pEncoderStream) const; 02798 02799 02800 llrp_bool_t 02801 isAllowedIn ( 02802 const CTypeDescriptor * pEnclosingElementType) const; 02803 02804 02805 static CElement * 02806 s_construct (void); 02807 02808 static void 02809 s_decodeFields ( 02810 CDecoderStream * pDecoderStream, 02811 CElement * pElement); 02813 02814 02815 protected: 02816 llrp_utf8v_t m_ModelName; 02817 02820 public: 02821 static const CFieldDescriptor 02822 s_fdModelName; 02824 02826 inline llrp_utf8v_t 02827 getModelName (void) 02828 { 02829 return m_ModelName; 02830 } 02831 02833 inline void 02834 setModelName ( 02835 llrp_utf8v_t value) 02836 { 02837 m_ModelName = value; 02838 } 02839 02840 02841 protected: 02842 llrp_utf8v_t m_SerialNumber; 02843 02846 public: 02847 static const CFieldDescriptor 02848 s_fdSerialNumber; 02850 02852 inline llrp_utf8v_t 02853 getSerialNumber (void) 02854 { 02855 return m_SerialNumber; 02856 } 02857 02859 inline void 02860 setSerialNumber ( 02861 llrp_utf8v_t value) 02862 { 02863 m_SerialNumber = value; 02864 } 02865 02866 02867 protected: 02868 llrp_utf8v_t m_SoftwareVersion; 02869 02872 public: 02873 static const CFieldDescriptor 02874 s_fdSoftwareVersion; 02876 02878 inline llrp_utf8v_t 02879 getSoftwareVersion (void) 02880 { 02881 return m_SoftwareVersion; 02882 } 02883 02885 inline void 02886 setSoftwareVersion ( 02887 llrp_utf8v_t value) 02888 { 02889 m_SoftwareVersion = value; 02890 } 02891 02892 02893 protected: 02894 llrp_utf8v_t m_FirmwareVersion; 02895 02898 public: 02899 static const CFieldDescriptor 02900 s_fdFirmwareVersion; 02902 02904 inline llrp_utf8v_t 02905 getFirmwareVersion (void) 02906 { 02907 return m_FirmwareVersion; 02908 } 02909 02911 inline void 02912 setFirmwareVersion ( 02913 llrp_utf8v_t value) 02914 { 02915 m_FirmwareVersion = value; 02916 } 02917 02918 02919 protected: 02920 llrp_utf8v_t m_FPGAVersion; 02921 02924 public: 02925 static const CFieldDescriptor 02926 s_fdFPGAVersion; 02928 02930 inline llrp_utf8v_t 02931 getFPGAVersion (void) 02932 { 02933 return m_FPGAVersion; 02934 } 02935 02937 inline void 02938 setFPGAVersion ( 02939 llrp_utf8v_t value) 02940 { 02941 m_FPGAVersion = value; 02942 } 02943 02944 02945 protected: 02946 llrp_utf8v_t m_PCBAVersion; 02947 02950 public: 02951 static const CFieldDescriptor 02952 s_fdPCBAVersion; 02954 02956 inline llrp_utf8v_t 02957 getPCBAVersion (void) 02958 { 02959 return m_PCBAVersion; 02960 } 02961 02963 inline void 02964 setPCBAVersion ( 02965 llrp_utf8v_t value) 02966 { 02967 m_PCBAVersion = value; 02968 } 02969 02970 02971 02972 protected: 02973 CImpinjHubVersions * m_pImpinjHubVersions; 02974 02975 public: 02977 inline CImpinjHubVersions * 02978 getImpinjHubVersions (void) 02979 { 02980 return m_pImpinjHubVersions; 02981 } 02982 02984 EResultCode 02985 setImpinjHubVersions ( 02986 CImpinjHubVersions * pValue); 02987 02988 02989 protected: 02990 CImpinjArrayVersion * m_pImpinjArrayVersion; 02991 02992 public: 02994 inline CImpinjArrayVersion * 02995 getImpinjArrayVersion (void) 02996 { 02997 return m_pImpinjArrayVersion; 02998 } 02999 03001 EResultCode 03002 setImpinjArrayVersion ( 03003 CImpinjArrayVersion * pValue); 03004 03005 03006 protected: 03007 CImpinjBLEVersion * m_pImpinjBLEVersion; 03008 03009 public: 03011 inline CImpinjBLEVersion * 03012 getImpinjBLEVersion (void) 03013 { 03014 return m_pImpinjBLEVersion; 03015 } 03016 03018 EResultCode 03019 setImpinjBLEVersion ( 03020 CImpinjBLEVersion * pValue); 03021 03022 03023 protected: 03024 std::list<CParameter *> m_listCustom; 03025 03026 public: 03028 inline std::list<CParameter *>::iterator 03029 beginCustom (void) 03030 { 03031 return m_listCustom.begin(); 03032 } 03033 03035 inline std::list<CParameter *>::iterator 03036 endCustom (void) 03037 { 03038 return m_listCustom.end(); 03039 } 03040 03042 inline void 03043 clearCustom (void) 03044 { 03045 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03046 } 03047 03049 inline int 03050 countCustom (void) 03051 { 03052 return (int) (m_listCustom.size()); 03053 } 03054 03055 EResultCode 03057 addCustom ( 03058 CParameter * pValue); 03059 03060 03061 }; 03062 03063 03088 class CImpinjFrequencyCapabilities : public CParameter 03089 { 03090 public: 03091 CImpinjFrequencyCapabilities (void); 03092 ~CImpinjFrequencyCapabilities (void); 03093 03096 03097 static const CFieldDescriptor * const 03098 s_apFieldDescriptorTable[]; 03099 03100 static const CTypeDescriptor 03101 s_typeDescriptor; 03102 03103 void 03104 decodeFields ( 03105 CDecoderStream * pDecoderStream); 03106 03107 void 03108 assimilateSubParameters ( 03109 CErrorDetails * pError); 03110 03111 void 03112 encode ( 03113 CEncoderStream * pEncoderStream) const; 03114 03115 03116 llrp_bool_t 03117 isAllowedIn ( 03118 const CTypeDescriptor * pEnclosingElementType) const; 03119 03120 03121 static CElement * 03122 s_construct (void); 03123 03124 static void 03125 s_decodeFields ( 03126 CDecoderStream * pDecoderStream, 03127 CElement * pElement); 03129 03130 03131 protected: 03132 llrp_u32v_t m_FrequencyList; 03133 03136 public: 03137 static const CFieldDescriptor 03138 s_fdFrequencyList; 03140 03142 inline llrp_u32v_t 03143 getFrequencyList (void) 03144 { 03145 return m_FrequencyList; 03146 } 03147 03149 inline void 03150 setFrequencyList ( 03151 llrp_u32v_t value) 03152 { 03153 m_FrequencyList = value; 03154 } 03155 03156 03157 03158 protected: 03159 std::list<CParameter *> m_listCustom; 03160 03161 public: 03163 inline std::list<CParameter *>::iterator 03164 beginCustom (void) 03165 { 03166 return m_listCustom.begin(); 03167 } 03168 03170 inline std::list<CParameter *>::iterator 03171 endCustom (void) 03172 { 03173 return m_listCustom.end(); 03174 } 03175 03177 inline void 03178 clearCustom (void) 03179 { 03180 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03181 } 03182 03184 inline int 03185 countCustom (void) 03186 { 03187 return (int) (m_listCustom.size()); 03188 } 03189 03190 EResultCode 03192 addCustom ( 03193 CParameter * pValue); 03194 03195 03196 }; 03197 03198 03225 class CImpinjGPIDebounceConfiguration : public CParameter 03226 { 03227 public: 03228 CImpinjGPIDebounceConfiguration (void); 03229 ~CImpinjGPIDebounceConfiguration (void); 03230 03233 03234 static const CFieldDescriptor * const 03235 s_apFieldDescriptorTable[]; 03236 03237 static const CTypeDescriptor 03238 s_typeDescriptor; 03239 03240 void 03241 decodeFields ( 03242 CDecoderStream * pDecoderStream); 03243 03244 void 03245 assimilateSubParameters ( 03246 CErrorDetails * pError); 03247 03248 void 03249 encode ( 03250 CEncoderStream * pEncoderStream) const; 03251 03252 03253 llrp_bool_t 03254 isAllowedIn ( 03255 const CTypeDescriptor * pEnclosingElementType) const; 03256 03257 03258 static CElement * 03259 s_construct (void); 03260 03261 static void 03262 s_decodeFields ( 03263 CDecoderStream * pDecoderStream, 03264 CElement * pElement); 03266 03267 03268 protected: 03269 llrp_u16_t m_GPIPortNum; 03270 03273 public: 03274 static const CFieldDescriptor 03275 s_fdGPIPortNum; 03277 03279 inline llrp_u16_t 03280 getGPIPortNum (void) 03281 { 03282 return m_GPIPortNum; 03283 } 03284 03286 inline void 03287 setGPIPortNum ( 03288 llrp_u16_t value) 03289 { 03290 m_GPIPortNum = value; 03291 } 03292 03293 03294 protected: 03295 llrp_u32_t m_GPIDebounceTimerMSec; 03296 03299 public: 03300 static const CFieldDescriptor 03301 s_fdGPIDebounceTimerMSec; 03303 03305 inline llrp_u32_t 03306 getGPIDebounceTimerMSec (void) 03307 { 03308 return m_GPIDebounceTimerMSec; 03309 } 03310 03312 inline void 03313 setGPIDebounceTimerMSec ( 03314 llrp_u32_t value) 03315 { 03316 m_GPIDebounceTimerMSec = value; 03317 } 03318 03319 03320 03321 protected: 03322 std::list<CParameter *> m_listCustom; 03323 03324 public: 03326 inline std::list<CParameter *>::iterator 03327 beginCustom (void) 03328 { 03329 return m_listCustom.begin(); 03330 } 03331 03333 inline std::list<CParameter *>::iterator 03334 endCustom (void) 03335 { 03336 return m_listCustom.end(); 03337 } 03338 03340 inline void 03341 clearCustom (void) 03342 { 03343 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03344 } 03345 03347 inline int 03348 countCustom (void) 03349 { 03350 return (int) (m_listCustom.size()); 03351 } 03352 03353 EResultCode 03355 addCustom ( 03356 CParameter * pValue); 03357 03358 03359 }; 03360 03361 03386 class CImpinjReaderTemperature : public CParameter 03387 { 03388 public: 03389 CImpinjReaderTemperature (void); 03390 ~CImpinjReaderTemperature (void); 03391 03394 03395 static const CFieldDescriptor * const 03396 s_apFieldDescriptorTable[]; 03397 03398 static const CTypeDescriptor 03399 s_typeDescriptor; 03400 03401 void 03402 decodeFields ( 03403 CDecoderStream * pDecoderStream); 03404 03405 void 03406 assimilateSubParameters ( 03407 CErrorDetails * pError); 03408 03409 void 03410 encode ( 03411 CEncoderStream * pEncoderStream) const; 03412 03413 03414 llrp_bool_t 03415 isAllowedIn ( 03416 const CTypeDescriptor * pEnclosingElementType) const; 03417 03418 03419 static CElement * 03420 s_construct (void); 03421 03422 static void 03423 s_decodeFields ( 03424 CDecoderStream * pDecoderStream, 03425 CElement * pElement); 03427 03428 03429 protected: 03430 llrp_s16_t m_Temperature; 03431 03434 public: 03435 static const CFieldDescriptor 03436 s_fdTemperature; 03438 03440 inline llrp_s16_t 03441 getTemperature (void) 03442 { 03443 return m_Temperature; 03444 } 03445 03447 inline void 03448 setTemperature ( 03449 llrp_s16_t value) 03450 { 03451 m_Temperature = value; 03452 } 03453 03454 03455 03456 protected: 03457 std::list<CParameter *> m_listCustom; 03458 03459 public: 03461 inline std::list<CParameter *>::iterator 03462 beginCustom (void) 03463 { 03464 return m_listCustom.begin(); 03465 } 03466 03468 inline std::list<CParameter *>::iterator 03469 endCustom (void) 03470 { 03471 return m_listCustom.end(); 03472 } 03473 03475 inline void 03476 clearCustom (void) 03477 { 03478 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03479 } 03480 03482 inline int 03483 countCustom (void) 03484 { 03485 return (int) (m_listCustom.size()); 03486 } 03487 03488 EResultCode 03490 addCustom ( 03491 CParameter * pValue); 03492 03493 03494 }; 03495 03496 03523 class CImpinjLinkMonitorConfiguration : public CParameter 03524 { 03525 public: 03526 CImpinjLinkMonitorConfiguration (void); 03527 ~CImpinjLinkMonitorConfiguration (void); 03528 03531 03532 static const CFieldDescriptor * const 03533 s_apFieldDescriptorTable[]; 03534 03535 static const CTypeDescriptor 03536 s_typeDescriptor; 03537 03538 void 03539 decodeFields ( 03540 CDecoderStream * pDecoderStream); 03541 03542 void 03543 assimilateSubParameters ( 03544 CErrorDetails * pError); 03545 03546 void 03547 encode ( 03548 CEncoderStream * pEncoderStream) const; 03549 03550 03551 llrp_bool_t 03552 isAllowedIn ( 03553 const CTypeDescriptor * pEnclosingElementType) const; 03554 03555 03556 static CElement * 03557 s_construct (void); 03558 03559 static void 03560 s_decodeFields ( 03561 CDecoderStream * pDecoderStream, 03562 CElement * pElement); 03564 03565 03566 protected: 03567 EImpinjLinkMonitorMode m_eLinkMonitorMode; 03568 03571 public: 03572 static const CFieldDescriptor 03573 s_fdLinkMonitorMode; 03575 03577 inline EImpinjLinkMonitorMode 03578 getLinkMonitorMode (void) 03579 { 03580 return m_eLinkMonitorMode; 03581 } 03582 03584 inline void 03585 setLinkMonitorMode ( 03586 EImpinjLinkMonitorMode value) 03587 { 03588 m_eLinkMonitorMode = value; 03589 } 03590 03591 03592 protected: 03593 llrp_u16_t m_LinkDownThreshold; 03594 03597 public: 03598 static const CFieldDescriptor 03599 s_fdLinkDownThreshold; 03601 03603 inline llrp_u16_t 03604 getLinkDownThreshold (void) 03605 { 03606 return m_LinkDownThreshold; 03607 } 03608 03610 inline void 03611 setLinkDownThreshold ( 03612 llrp_u16_t value) 03613 { 03614 m_LinkDownThreshold = value; 03615 } 03616 03617 03618 03619 protected: 03620 std::list<CParameter *> m_listCustom; 03621 03622 public: 03624 inline std::list<CParameter *>::iterator 03625 beginCustom (void) 03626 { 03627 return m_listCustom.begin(); 03628 } 03629 03631 inline std::list<CParameter *>::iterator 03632 endCustom (void) 03633 { 03634 return m_listCustom.end(); 03635 } 03636 03638 inline void 03639 clearCustom (void) 03640 { 03641 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03642 } 03643 03645 inline int 03646 countCustom (void) 03647 { 03648 return (int) (m_listCustom.size()); 03649 } 03650 03651 EResultCode 03653 addCustom ( 03654 CParameter * pValue); 03655 03656 03657 }; 03658 03659 03685 class CImpinjReportBufferConfiguration : public CParameter 03686 { 03687 public: 03688 CImpinjReportBufferConfiguration (void); 03689 ~CImpinjReportBufferConfiguration (void); 03690 03693 03694 static const CFieldDescriptor * const 03695 s_apFieldDescriptorTable[]; 03696 03697 static const CTypeDescriptor 03698 s_typeDescriptor; 03699 03700 void 03701 decodeFields ( 03702 CDecoderStream * pDecoderStream); 03703 03704 void 03705 assimilateSubParameters ( 03706 CErrorDetails * pError); 03707 03708 void 03709 encode ( 03710 CEncoderStream * pEncoderStream) const; 03711 03712 03713 llrp_bool_t 03714 isAllowedIn ( 03715 const CTypeDescriptor * pEnclosingElementType) const; 03716 03717 03718 static CElement * 03719 s_construct (void); 03720 03721 static void 03722 s_decodeFields ( 03723 CDecoderStream * pDecoderStream, 03724 CElement * pElement); 03726 03727 03728 protected: 03729 EImpinjReportBufferMode m_eReportBufferMode; 03730 03733 public: 03734 static const CFieldDescriptor 03735 s_fdReportBufferMode; 03737 03739 inline EImpinjReportBufferMode 03740 getReportBufferMode (void) 03741 { 03742 return m_eReportBufferMode; 03743 } 03744 03746 inline void 03747 setReportBufferMode ( 03748 EImpinjReportBufferMode value) 03749 { 03750 m_eReportBufferMode = value; 03751 } 03752 03753 03754 03755 protected: 03756 std::list<CParameter *> m_listCustom; 03757 03758 public: 03760 inline std::list<CParameter *>::iterator 03761 beginCustom (void) 03762 { 03763 return m_listCustom.begin(); 03764 } 03765 03767 inline std::list<CParameter *>::iterator 03768 endCustom (void) 03769 { 03770 return m_listCustom.end(); 03771 } 03772 03774 inline void 03775 clearCustom (void) 03776 { 03777 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03778 } 03779 03781 inline int 03782 countCustom (void) 03783 { 03784 return (int) (m_listCustom.size()); 03785 } 03786 03787 EResultCode 03789 addCustom ( 03790 CParameter * pValue); 03791 03792 03793 }; 03794 03795 03824 class CImpinjAccessSpecConfiguration : public CParameter 03825 { 03826 public: 03827 CImpinjAccessSpecConfiguration (void); 03828 ~CImpinjAccessSpecConfiguration (void); 03829 03832 03833 static const CFieldDescriptor * const 03834 s_apFieldDescriptorTable[]; 03835 03836 static const CTypeDescriptor 03837 s_typeDescriptor; 03838 03839 void 03840 decodeFields ( 03841 CDecoderStream * pDecoderStream); 03842 03843 void 03844 assimilateSubParameters ( 03845 CErrorDetails * pError); 03846 03847 void 03848 encode ( 03849 CEncoderStream * pEncoderStream) const; 03850 03851 03852 llrp_bool_t 03853 isAllowedIn ( 03854 const CTypeDescriptor * pEnclosingElementType) const; 03855 03856 03857 static CElement * 03858 s_construct (void); 03859 03860 static void 03861 s_decodeFields ( 03862 CDecoderStream * pDecoderStream, 03863 CElement * pElement); 03865 03866 03867 03868 protected: 03869 CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount; 03870 03871 public: 03873 inline CImpinjBlockWriteWordCount * 03874 getImpinjBlockWriteWordCount (void) 03875 { 03876 return m_pImpinjBlockWriteWordCount; 03877 } 03878 03880 EResultCode 03881 setImpinjBlockWriteWordCount ( 03882 CImpinjBlockWriteWordCount * pValue); 03883 03884 03885 protected: 03886 CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount; 03887 03888 public: 03890 inline CImpinjOpSpecRetryCount * 03891 getImpinjOpSpecRetryCount (void) 03892 { 03893 return m_pImpinjOpSpecRetryCount; 03894 } 03895 03897 EResultCode 03898 setImpinjOpSpecRetryCount ( 03899 CImpinjOpSpecRetryCount * pValue); 03900 03901 03902 protected: 03903 CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering; 03904 03905 public: 03907 inline CImpinjAccessSpecOrdering * 03908 getImpinjAccessSpecOrdering (void) 03909 { 03910 return m_pImpinjAccessSpecOrdering; 03911 } 03912 03914 EResultCode 03915 setImpinjAccessSpecOrdering ( 03916 CImpinjAccessSpecOrdering * pValue); 03917 03918 03919 protected: 03920 std::list<CParameter *> m_listCustom; 03921 03922 public: 03924 inline std::list<CParameter *>::iterator 03925 beginCustom (void) 03926 { 03927 return m_listCustom.begin(); 03928 } 03929 03931 inline std::list<CParameter *>::iterator 03932 endCustom (void) 03933 { 03934 return m_listCustom.end(); 03935 } 03936 03938 inline void 03939 clearCustom (void) 03940 { 03941 clearSubParameterList ((tListOfParameters *) &m_listCustom); 03942 } 03943 03945 inline int 03946 countCustom (void) 03947 { 03948 return (int) (m_listCustom.size()); 03949 } 03950 03951 EResultCode 03953 addCustom ( 03954 CParameter * pValue); 03955 03956 03957 }; 03958 03959 03983 class CImpinjBlockWriteWordCount : public CParameter 03984 { 03985 public: 03986 CImpinjBlockWriteWordCount (void); 03987 ~CImpinjBlockWriteWordCount (void); 03988 03991 03992 static const CFieldDescriptor * const 03993 s_apFieldDescriptorTable[]; 03994 03995 static const CTypeDescriptor 03996 s_typeDescriptor; 03997 03998 void 03999 decodeFields ( 04000 CDecoderStream * pDecoderStream); 04001 04002 void 04003 assimilateSubParameters ( 04004 CErrorDetails * pError); 04005 04006 void 04007 encode ( 04008 CEncoderStream * pEncoderStream) const; 04009 04010 04011 llrp_bool_t 04012 isAllowedIn ( 04013 const CTypeDescriptor * pEnclosingElementType) const; 04014 04015 04016 static CElement * 04017 s_construct (void); 04018 04019 static void 04020 s_decodeFields ( 04021 CDecoderStream * pDecoderStream, 04022 CElement * pElement); 04024 04025 04026 protected: 04027 llrp_u16_t m_WordCount; 04028 04031 public: 04032 static const CFieldDescriptor 04033 s_fdWordCount; 04035 04037 inline llrp_u16_t 04038 getWordCount (void) 04039 { 04040 return m_WordCount; 04041 } 04042 04044 inline void 04045 setWordCount ( 04046 llrp_u16_t value) 04047 { 04048 m_WordCount = value; 04049 } 04050 04051 04052 04053 protected: 04054 std::list<CParameter *> m_listCustom; 04055 04056 public: 04058 inline std::list<CParameter *>::iterator 04059 beginCustom (void) 04060 { 04061 return m_listCustom.begin(); 04062 } 04063 04065 inline std::list<CParameter *>::iterator 04066 endCustom (void) 04067 { 04068 return m_listCustom.end(); 04069 } 04070 04072 inline void 04073 clearCustom (void) 04074 { 04075 clearSubParameterList ((tListOfParameters *) &m_listCustom); 04076 } 04077 04079 inline int 04080 countCustom (void) 04081 { 04082 return (int) (m_listCustom.size()); 04083 } 04084 04085 EResultCode 04087 addCustom ( 04088 CParameter * pValue); 04089 04090 04091 }; 04092 04093 04123 class CImpinjBlockPermalock : public CParameter 04124 { 04125 public: 04126 CImpinjBlockPermalock (void); 04127 ~CImpinjBlockPermalock (void); 04128 04131 04132 static const CFieldDescriptor * const 04133 s_apFieldDescriptorTable[]; 04134 04135 static const CTypeDescriptor 04136 s_typeDescriptor; 04137 04138 void 04139 decodeFields ( 04140 CDecoderStream * pDecoderStream); 04141 04142 void 04143 assimilateSubParameters ( 04144 CErrorDetails * pError); 04145 04146 void 04147 encode ( 04148 CEncoderStream * pEncoderStream) const; 04149 04150 04151 llrp_bool_t 04152 isAllowedIn ( 04153 const CTypeDescriptor * pEnclosingElementType) const; 04154 04155 04156 static CElement * 04157 s_construct (void); 04158 04159 static void 04160 s_decodeFields ( 04161 CDecoderStream * pDecoderStream, 04162 CElement * pElement); 04164 04165 04166 protected: 04167 llrp_u16_t m_OpSpecID; 04168 04171 public: 04172 static const CFieldDescriptor 04173 s_fdOpSpecID; 04175 04177 inline llrp_u16_t 04178 getOpSpecID (void) 04179 { 04180 return m_OpSpecID; 04181 } 04182 04184 inline void 04185 setOpSpecID ( 04186 llrp_u16_t value) 04187 { 04188 m_OpSpecID = value; 04189 } 04190 04191 04192 protected: 04193 llrp_u32_t m_AccessPassword; 04194 04197 public: 04198 static const CFieldDescriptor 04199 s_fdAccessPassword; 04201 04203 inline llrp_u32_t 04204 getAccessPassword (void) 04205 { 04206 return m_AccessPassword; 04207 } 04208 04210 inline void 04211 setAccessPassword ( 04212 llrp_u32_t value) 04213 { 04214 m_AccessPassword = value; 04215 } 04216 04217 04218 protected: 04219 llrp_u2_t m_MB; 04220 04223 public: 04224 static const CFieldDescriptor 04225 s_fdMB; 04227 04229 inline llrp_u2_t 04230 getMB (void) 04231 { 04232 return m_MB; 04233 } 04234 04236 inline void 04237 setMB ( 04238 llrp_u2_t value) 04239 { 04240 m_MB = value; 04241 } 04242 04243 04244 protected: 04245 llrp_u16_t m_BlockPointer; 04246 04249 public: 04250 static const CFieldDescriptor 04251 s_fdBlockPointer; 04253 04255 inline llrp_u16_t 04256 getBlockPointer (void) 04257 { 04258 return m_BlockPointer; 04259 } 04260 04262 inline void 04263 setBlockPointer ( 04264 llrp_u16_t value) 04265 { 04266 m_BlockPointer = value; 04267 } 04268 04269 04270 protected: 04271 llrp_u16v_t m_BlockMask; 04272 04275 public: 04276 static const CFieldDescriptor 04277 s_fdBlockMask; 04279 04281 inline llrp_u16v_t 04282 getBlockMask (void) 04283 { 04284 return m_BlockMask; 04285 } 04286 04288 inline void 04289 setBlockMask ( 04290 llrp_u16v_t value) 04291 { 04292 m_BlockMask = value; 04293 } 04294 04295 04296 04297 protected: 04298 std::list<CParameter *> m_listCustom; 04299 04300 public: 04302 inline std::list<CParameter *>::iterator 04303 beginCustom (void) 04304 { 04305 return m_listCustom.begin(); 04306 } 04307 04309 inline std::list<CParameter *>::iterator 04310 endCustom (void) 04311 { 04312 return m_listCustom.end(); 04313 } 04314 04316 inline void 04317 clearCustom (void) 04318 { 04319 clearSubParameterList ((tListOfParameters *) &m_listCustom); 04320 } 04321 04323 inline int 04324 countCustom (void) 04325 { 04326 return (int) (m_listCustom.size()); 04327 } 04328 04329 EResultCode 04331 addCustom ( 04332 CParameter * pValue); 04333 04334 04335 }; 04336 04337 04363 class CImpinjBlockPermalockOpSpecResult : public CParameter 04364 { 04365 public: 04366 CImpinjBlockPermalockOpSpecResult (void); 04367 ~CImpinjBlockPermalockOpSpecResult (void); 04368 04371 04372 static const CFieldDescriptor * const 04373 s_apFieldDescriptorTable[]; 04374 04375 static const CTypeDescriptor 04376 s_typeDescriptor; 04377 04378 void 04379 decodeFields ( 04380 CDecoderStream * pDecoderStream); 04381 04382 void 04383 assimilateSubParameters ( 04384 CErrorDetails * pError); 04385 04386 void 04387 encode ( 04388 CEncoderStream * pEncoderStream) const; 04389 04390 04391 llrp_bool_t 04392 isAllowedIn ( 04393 const CTypeDescriptor * pEnclosingElementType) const; 04394 04395 04396 static CElement * 04397 s_construct (void); 04398 04399 static void 04400 s_decodeFields ( 04401 CDecoderStream * pDecoderStream, 04402 CElement * pElement); 04404 04405 04406 protected: 04407 EImpinjBlockPermalockResultType m_eResult; 04408 04411 public: 04412 static const CFieldDescriptor 04413 s_fdResult; 04415 04417 inline EImpinjBlockPermalockResultType 04418 getResult (void) 04419 { 04420 return m_eResult; 04421 } 04422 04424 inline void 04425 setResult ( 04426 EImpinjBlockPermalockResultType value) 04427 { 04428 m_eResult = value; 04429 } 04430 04431 04432 protected: 04433 llrp_u16_t m_OpSpecID; 04434 04437 public: 04438 static const CFieldDescriptor 04439 s_fdOpSpecID; 04441 04443 inline llrp_u16_t 04444 getOpSpecID (void) 04445 { 04446 return m_OpSpecID; 04447 } 04448 04450 inline void 04451 setOpSpecID ( 04452 llrp_u16_t value) 04453 { 04454 m_OpSpecID = value; 04455 } 04456 04457 04458 04459 protected: 04460 std::list<CParameter *> m_listCustom; 04461 04462 public: 04464 inline std::list<CParameter *>::iterator 04465 beginCustom (void) 04466 { 04467 return m_listCustom.begin(); 04468 } 04469 04471 inline std::list<CParameter *>::iterator 04472 endCustom (void) 04473 { 04474 return m_listCustom.end(); 04475 } 04476 04478 inline void 04479 clearCustom (void) 04480 { 04481 clearSubParameterList ((tListOfParameters *) &m_listCustom); 04482 } 04483 04485 inline int 04486 countCustom (void) 04487 { 04488 return (int) (m_listCustom.size()); 04489 } 04490 04491 EResultCode 04493 addCustom ( 04494 CParameter * pValue); 04495 04496 04497 }; 04498 04499 04529 class CImpinjGetBlockPermalockStatus : public CParameter 04530 { 04531 public: 04532 CImpinjGetBlockPermalockStatus (void); 04533 ~CImpinjGetBlockPermalockStatus (void); 04534 04537 04538 static const CFieldDescriptor * const 04539 s_apFieldDescriptorTable[]; 04540 04541 static const CTypeDescriptor 04542 s_typeDescriptor; 04543 04544 void 04545 decodeFields ( 04546 CDecoderStream * pDecoderStream); 04547 04548 void 04549 assimilateSubParameters ( 04550 CErrorDetails * pError); 04551 04552 void 04553 encode ( 04554 CEncoderStream * pEncoderStream) const; 04555 04556 04557 llrp_bool_t 04558 isAllowedIn ( 04559 const CTypeDescriptor * pEnclosingElementType) const; 04560 04561 04562 static CElement * 04563 s_construct (void); 04564 04565 static void 04566 s_decodeFields ( 04567 CDecoderStream * pDecoderStream, 04568 CElement * pElement); 04570 04571 04572 protected: 04573 llrp_u16_t m_OpSpecID; 04574 04577 public: 04578 static const CFieldDescriptor 04579 s_fdOpSpecID; 04581 04583 inline llrp_u16_t 04584 getOpSpecID (void) 04585 { 04586 return m_OpSpecID; 04587 } 04588 04590 inline void 04591 setOpSpecID ( 04592 llrp_u16_t value) 04593 { 04594 m_OpSpecID = value; 04595 } 04596 04597 04598 protected: 04599 llrp_u32_t m_AccessPassword; 04600 04603 public: 04604 static const CFieldDescriptor 04605 s_fdAccessPassword; 04607 04609 inline llrp_u32_t 04610 getAccessPassword (void) 04611 { 04612 return m_AccessPassword; 04613 } 04614 04616 inline void 04617 setAccessPassword ( 04618 llrp_u32_t value) 04619 { 04620 m_AccessPassword = value; 04621 } 04622 04623 04624 protected: 04625 llrp_u2_t m_MB; 04626 04629 public: 04630 static const CFieldDescriptor 04631 s_fdMB; 04633 04635 inline llrp_u2_t 04636 getMB (void) 04637 { 04638 return m_MB; 04639 } 04640 04642 inline void 04643 setMB ( 04644 llrp_u2_t value) 04645 { 04646 m_MB = value; 04647 } 04648 04649 04650 protected: 04651 llrp_u16_t m_BlockPointer; 04652 04655 public: 04656 static const CFieldDescriptor 04657 s_fdBlockPointer; 04659 04661 inline llrp_u16_t 04662 getBlockPointer (void) 04663 { 04664 return m_BlockPointer; 04665 } 04666 04668 inline void 04669 setBlockPointer ( 04670 llrp_u16_t value) 04671 { 04672 m_BlockPointer = value; 04673 } 04674 04675 04676 protected: 04677 llrp_u16_t m_BlockRange; 04678 04681 public: 04682 static const CFieldDescriptor 04683 s_fdBlockRange; 04685 04687 inline llrp_u16_t 04688 getBlockRange (void) 04689 { 04690 return m_BlockRange; 04691 } 04692 04694 inline void 04695 setBlockRange ( 04696 llrp_u16_t value) 04697 { 04698 m_BlockRange = value; 04699 } 04700 04701 04702 04703 protected: 04704 std::list<CParameter *> m_listCustom; 04705 04706 public: 04708 inline std::list<CParameter *>::iterator 04709 beginCustom (void) 04710 { 04711 return m_listCustom.begin(); 04712 } 04713 04715 inline std::list<CParameter *>::iterator 04716 endCustom (void) 04717 { 04718 return m_listCustom.end(); 04719 } 04720 04722 inline void 04723 clearCustom (void) 04724 { 04725 clearSubParameterList ((tListOfParameters *) &m_listCustom); 04726 } 04727 04729 inline int 04730 countCustom (void) 04731 { 04732 return (int) (m_listCustom.size()); 04733 } 04734 04735 EResultCode 04737 addCustom ( 04738 CParameter * pValue); 04739 04740 04741 }; 04742 04743 04770 class CImpinjGetBlockPermalockStatusOpSpecResult : public CParameter 04771 { 04772 public: 04773 CImpinjGetBlockPermalockStatusOpSpecResult (void); 04774 ~CImpinjGetBlockPermalockStatusOpSpecResult (void); 04775 04778 04779 static const CFieldDescriptor * const 04780 s_apFieldDescriptorTable[]; 04781 04782 static const CTypeDescriptor 04783 s_typeDescriptor; 04784 04785 void 04786 decodeFields ( 04787 CDecoderStream * pDecoderStream); 04788 04789 void 04790 assimilateSubParameters ( 04791 CErrorDetails * pError); 04792 04793 void 04794 encode ( 04795 CEncoderStream * pEncoderStream) const; 04796 04797 04798 llrp_bool_t 04799 isAllowedIn ( 04800 const CTypeDescriptor * pEnclosingElementType) const; 04801 04802 04803 static CElement * 04804 s_construct (void); 04805 04806 static void 04807 s_decodeFields ( 04808 CDecoderStream * pDecoderStream, 04809 CElement * pElement); 04811 04812 04813 protected: 04814 EImpinjGetBlockPermalockStatusResultType m_eResult; 04815 04818 public: 04819 static const CFieldDescriptor 04820 s_fdResult; 04822 04824 inline EImpinjGetBlockPermalockStatusResultType 04825 getResult (void) 04826 { 04827 return m_eResult; 04828 } 04829 04831 inline void 04832 setResult ( 04833 EImpinjGetBlockPermalockStatusResultType value) 04834 { 04835 m_eResult = value; 04836 } 04837 04838 04839 protected: 04840 llrp_u16_t m_OpSpecID; 04841 04844 public: 04845 static const CFieldDescriptor 04846 s_fdOpSpecID; 04848 04850 inline llrp_u16_t 04851 getOpSpecID (void) 04852 { 04853 return m_OpSpecID; 04854 } 04855 04857 inline void 04858 setOpSpecID ( 04859 llrp_u16_t value) 04860 { 04861 m_OpSpecID = value; 04862 } 04863 04864 04865 protected: 04866 llrp_u16v_t m_PermalockStatus; 04867 04870 public: 04871 static const CFieldDescriptor 04872 s_fdPermalockStatus; 04874 04876 inline llrp_u16v_t 04877 getPermalockStatus (void) 04878 { 04879 return m_PermalockStatus; 04880 } 04881 04883 inline void 04884 setPermalockStatus ( 04885 llrp_u16v_t value) 04886 { 04887 m_PermalockStatus = value; 04888 } 04889 04890 04891 04892 protected: 04893 std::list<CParameter *> m_listCustom; 04894 04895 public: 04897 inline std::list<CParameter *>::iterator 04898 beginCustom (void) 04899 { 04900 return m_listCustom.begin(); 04901 } 04902 04904 inline std::list<CParameter *>::iterator 04905 endCustom (void) 04906 { 04907 return m_listCustom.end(); 04908 } 04909 04911 inline void 04912 clearCustom (void) 04913 { 04914 clearSubParameterList ((tListOfParameters *) &m_listCustom); 04915 } 04916 04918 inline int 04919 countCustom (void) 04920 { 04921 return (int) (m_listCustom.size()); 04922 } 04923 04924 EResultCode 04926 addCustom ( 04927 CParameter * pValue); 04928 04929 04930 }; 04931 04932 04962 class CImpinjSetQTConfig : public CParameter 04963 { 04964 public: 04965 CImpinjSetQTConfig (void); 04966 ~CImpinjSetQTConfig (void); 04967 04970 04971 static const CFieldDescriptor * const 04972 s_apFieldDescriptorTable[]; 04973 04974 static const CTypeDescriptor 04975 s_typeDescriptor; 04976 04977 void 04978 decodeFields ( 04979 CDecoderStream * pDecoderStream); 04980 04981 void 04982 assimilateSubParameters ( 04983 CErrorDetails * pError); 04984 04985 void 04986 encode ( 04987 CEncoderStream * pEncoderStream) const; 04988 04989 04990 llrp_bool_t 04991 isAllowedIn ( 04992 const CTypeDescriptor * pEnclosingElementType) const; 04993 04994 04995 static CElement * 04996 s_construct (void); 04997 04998 static void 04999 s_decodeFields ( 05000 CDecoderStream * pDecoderStream, 05001 CElement * pElement); 05003 05004 05005 protected: 05006 llrp_u16_t m_OpSpecID; 05007 05010 public: 05011 static const CFieldDescriptor 05012 s_fdOpSpecID; 05014 05016 inline llrp_u16_t 05017 getOpSpecID (void) 05018 { 05019 return m_OpSpecID; 05020 } 05021 05023 inline void 05024 setOpSpecID ( 05025 llrp_u16_t value) 05026 { 05027 m_OpSpecID = value; 05028 } 05029 05030 05031 protected: 05032 llrp_u32_t m_AccessPassword; 05033 05036 public: 05037 static const CFieldDescriptor 05038 s_fdAccessPassword; 05040 05042 inline llrp_u32_t 05043 getAccessPassword (void) 05044 { 05045 return m_AccessPassword; 05046 } 05047 05049 inline void 05050 setAccessPassword ( 05051 llrp_u32_t value) 05052 { 05053 m_AccessPassword = value; 05054 } 05055 05056 05057 protected: 05058 EImpinjQTDataProfile m_eDataProfile; 05059 05062 public: 05063 static const CFieldDescriptor 05064 s_fdDataProfile; 05066 05068 inline EImpinjQTDataProfile 05069 getDataProfile (void) 05070 { 05071 return m_eDataProfile; 05072 } 05073 05075 inline void 05076 setDataProfile ( 05077 EImpinjQTDataProfile value) 05078 { 05079 m_eDataProfile = value; 05080 } 05081 05082 05083 protected: 05084 EImpinjQTAccessRange m_eAccessRange; 05085 05088 public: 05089 static const CFieldDescriptor 05090 s_fdAccessRange; 05092 05094 inline EImpinjQTAccessRange 05095 getAccessRange (void) 05096 { 05097 return m_eAccessRange; 05098 } 05099 05101 inline void 05102 setAccessRange ( 05103 EImpinjQTAccessRange value) 05104 { 05105 m_eAccessRange = value; 05106 } 05107 05108 05109 protected: 05110 EImpinjQTPersistence m_ePersistence; 05111 05114 public: 05115 static const CFieldDescriptor 05116 s_fdPersistence; 05118 05120 inline EImpinjQTPersistence 05121 getPersistence (void) 05122 { 05123 return m_ePersistence; 05124 } 05125 05127 inline void 05128 setPersistence ( 05129 EImpinjQTPersistence value) 05130 { 05131 m_ePersistence = value; 05132 } 05133 05134 05135 05136 protected: 05137 std::list<CParameter *> m_listCustom; 05138 05139 public: 05141 inline std::list<CParameter *>::iterator 05142 beginCustom (void) 05143 { 05144 return m_listCustom.begin(); 05145 } 05146 05148 inline std::list<CParameter *>::iterator 05149 endCustom (void) 05150 { 05151 return m_listCustom.end(); 05152 } 05153 05155 inline void 05156 clearCustom (void) 05157 { 05158 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05159 } 05160 05162 inline int 05163 countCustom (void) 05164 { 05165 return (int) (m_listCustom.size()); 05166 } 05167 05168 EResultCode 05170 addCustom ( 05171 CParameter * pValue); 05172 05173 05174 }; 05175 05176 05202 class CImpinjSetQTConfigOpSpecResult : public CParameter 05203 { 05204 public: 05205 CImpinjSetQTConfigOpSpecResult (void); 05206 ~CImpinjSetQTConfigOpSpecResult (void); 05207 05210 05211 static const CFieldDescriptor * const 05212 s_apFieldDescriptorTable[]; 05213 05214 static const CTypeDescriptor 05215 s_typeDescriptor; 05216 05217 void 05218 decodeFields ( 05219 CDecoderStream * pDecoderStream); 05220 05221 void 05222 assimilateSubParameters ( 05223 CErrorDetails * pError); 05224 05225 void 05226 encode ( 05227 CEncoderStream * pEncoderStream) const; 05228 05229 05230 llrp_bool_t 05231 isAllowedIn ( 05232 const CTypeDescriptor * pEnclosingElementType) const; 05233 05234 05235 static CElement * 05236 s_construct (void); 05237 05238 static void 05239 s_decodeFields ( 05240 CDecoderStream * pDecoderStream, 05241 CElement * pElement); 05243 05244 05245 protected: 05246 EImpinjSetQTConfigResultType m_eResult; 05247 05250 public: 05251 static const CFieldDescriptor 05252 s_fdResult; 05254 05256 inline EImpinjSetQTConfigResultType 05257 getResult (void) 05258 { 05259 return m_eResult; 05260 } 05261 05263 inline void 05264 setResult ( 05265 EImpinjSetQTConfigResultType value) 05266 { 05267 m_eResult = value; 05268 } 05269 05270 05271 protected: 05272 llrp_u16_t m_OpSpecID; 05273 05276 public: 05277 static const CFieldDescriptor 05278 s_fdOpSpecID; 05280 05282 inline llrp_u16_t 05283 getOpSpecID (void) 05284 { 05285 return m_OpSpecID; 05286 } 05287 05289 inline void 05290 setOpSpecID ( 05291 llrp_u16_t value) 05292 { 05293 m_OpSpecID = value; 05294 } 05295 05296 05297 05298 protected: 05299 std::list<CParameter *> m_listCustom; 05300 05301 public: 05303 inline std::list<CParameter *>::iterator 05304 beginCustom (void) 05305 { 05306 return m_listCustom.begin(); 05307 } 05308 05310 inline std::list<CParameter *>::iterator 05311 endCustom (void) 05312 { 05313 return m_listCustom.end(); 05314 } 05315 05317 inline void 05318 clearCustom (void) 05319 { 05320 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05321 } 05322 05324 inline int 05325 countCustom (void) 05326 { 05327 return (int) (m_listCustom.size()); 05328 } 05329 05330 EResultCode 05332 addCustom ( 05333 CParameter * pValue); 05334 05335 05336 }; 05337 05338 05364 class CImpinjGetQTConfig : public CParameter 05365 { 05366 public: 05367 CImpinjGetQTConfig (void); 05368 ~CImpinjGetQTConfig (void); 05369 05372 05373 static const CFieldDescriptor * const 05374 s_apFieldDescriptorTable[]; 05375 05376 static const CTypeDescriptor 05377 s_typeDescriptor; 05378 05379 void 05380 decodeFields ( 05381 CDecoderStream * pDecoderStream); 05382 05383 void 05384 assimilateSubParameters ( 05385 CErrorDetails * pError); 05386 05387 void 05388 encode ( 05389 CEncoderStream * pEncoderStream) const; 05390 05391 05392 llrp_bool_t 05393 isAllowedIn ( 05394 const CTypeDescriptor * pEnclosingElementType) const; 05395 05396 05397 static CElement * 05398 s_construct (void); 05399 05400 static void 05401 s_decodeFields ( 05402 CDecoderStream * pDecoderStream, 05403 CElement * pElement); 05405 05406 05407 protected: 05408 llrp_u16_t m_OpSpecID; 05409 05412 public: 05413 static const CFieldDescriptor 05414 s_fdOpSpecID; 05416 05418 inline llrp_u16_t 05419 getOpSpecID (void) 05420 { 05421 return m_OpSpecID; 05422 } 05423 05425 inline void 05426 setOpSpecID ( 05427 llrp_u16_t value) 05428 { 05429 m_OpSpecID = value; 05430 } 05431 05432 05433 protected: 05434 llrp_u32_t m_AccessPassword; 05435 05438 public: 05439 static const CFieldDescriptor 05440 s_fdAccessPassword; 05442 05444 inline llrp_u32_t 05445 getAccessPassword (void) 05446 { 05447 return m_AccessPassword; 05448 } 05449 05451 inline void 05452 setAccessPassword ( 05453 llrp_u32_t value) 05454 { 05455 m_AccessPassword = value; 05456 } 05457 05458 05459 05460 protected: 05461 std::list<CParameter *> m_listCustom; 05462 05463 public: 05465 inline std::list<CParameter *>::iterator 05466 beginCustom (void) 05467 { 05468 return m_listCustom.begin(); 05469 } 05470 05472 inline std::list<CParameter *>::iterator 05473 endCustom (void) 05474 { 05475 return m_listCustom.end(); 05476 } 05477 05479 inline void 05480 clearCustom (void) 05481 { 05482 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05483 } 05484 05486 inline int 05487 countCustom (void) 05488 { 05489 return (int) (m_listCustom.size()); 05490 } 05491 05492 EResultCode 05494 addCustom ( 05495 CParameter * pValue); 05496 05497 05498 }; 05499 05500 05529 class CImpinjGetQTConfigOpSpecResult : public CParameter 05530 { 05531 public: 05532 CImpinjGetQTConfigOpSpecResult (void); 05533 ~CImpinjGetQTConfigOpSpecResult (void); 05534 05537 05538 static const CFieldDescriptor * const 05539 s_apFieldDescriptorTable[]; 05540 05541 static const CTypeDescriptor 05542 s_typeDescriptor; 05543 05544 void 05545 decodeFields ( 05546 CDecoderStream * pDecoderStream); 05547 05548 void 05549 assimilateSubParameters ( 05550 CErrorDetails * pError); 05551 05552 void 05553 encode ( 05554 CEncoderStream * pEncoderStream) const; 05555 05556 05557 llrp_bool_t 05558 isAllowedIn ( 05559 const CTypeDescriptor * pEnclosingElementType) const; 05560 05561 05562 static CElement * 05563 s_construct (void); 05564 05565 static void 05566 s_decodeFields ( 05567 CDecoderStream * pDecoderStream, 05568 CElement * pElement); 05570 05571 05572 protected: 05573 EImpinjGetQTConfigResultType m_eResult; 05574 05577 public: 05578 static const CFieldDescriptor 05579 s_fdResult; 05581 05583 inline EImpinjGetQTConfigResultType 05584 getResult (void) 05585 { 05586 return m_eResult; 05587 } 05588 05590 inline void 05591 setResult ( 05592 EImpinjGetQTConfigResultType value) 05593 { 05594 m_eResult = value; 05595 } 05596 05597 05598 protected: 05599 llrp_u16_t m_OpSpecID; 05600 05603 public: 05604 static const CFieldDescriptor 05605 s_fdOpSpecID; 05607 05609 inline llrp_u16_t 05610 getOpSpecID (void) 05611 { 05612 return m_OpSpecID; 05613 } 05614 05616 inline void 05617 setOpSpecID ( 05618 llrp_u16_t value) 05619 { 05620 m_OpSpecID = value; 05621 } 05622 05623 05624 protected: 05625 EImpinjQTDataProfile m_eDataProfile; 05626 05629 public: 05630 static const CFieldDescriptor 05631 s_fdDataProfile; 05633 05635 inline EImpinjQTDataProfile 05636 getDataProfile (void) 05637 { 05638 return m_eDataProfile; 05639 } 05640 05642 inline void 05643 setDataProfile ( 05644 EImpinjQTDataProfile value) 05645 { 05646 m_eDataProfile = value; 05647 } 05648 05649 05650 protected: 05651 EImpinjQTAccessRange m_eAccessRange; 05652 05655 public: 05656 static const CFieldDescriptor 05657 s_fdAccessRange; 05659 05661 inline EImpinjQTAccessRange 05662 getAccessRange (void) 05663 { 05664 return m_eAccessRange; 05665 } 05666 05668 inline void 05669 setAccessRange ( 05670 EImpinjQTAccessRange value) 05671 { 05672 m_eAccessRange = value; 05673 } 05674 05675 05676 05677 protected: 05678 std::list<CParameter *> m_listCustom; 05679 05680 public: 05682 inline std::list<CParameter *>::iterator 05683 beginCustom (void) 05684 { 05685 return m_listCustom.begin(); 05686 } 05687 05689 inline std::list<CParameter *>::iterator 05690 endCustom (void) 05691 { 05692 return m_listCustom.end(); 05693 } 05694 05696 inline void 05697 clearCustom (void) 05698 { 05699 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05700 } 05701 05703 inline int 05704 countCustom (void) 05705 { 05706 return (int) (m_listCustom.size()); 05707 } 05708 05709 EResultCode 05711 addCustom ( 05712 CParameter * pValue); 05713 05714 05715 }; 05716 05717 05747 class CImpinjTagReportContentSelector : public CParameter 05748 { 05749 public: 05750 CImpinjTagReportContentSelector (void); 05751 ~CImpinjTagReportContentSelector (void); 05752 05755 05756 static const CFieldDescriptor * const 05757 s_apFieldDescriptorTable[]; 05758 05759 static const CTypeDescriptor 05760 s_typeDescriptor; 05761 05762 void 05763 decodeFields ( 05764 CDecoderStream * pDecoderStream); 05765 05766 void 05767 assimilateSubParameters ( 05768 CErrorDetails * pError); 05769 05770 void 05771 encode ( 05772 CEncoderStream * pEncoderStream) const; 05773 05774 05775 llrp_bool_t 05776 isAllowedIn ( 05777 const CTypeDescriptor * pEnclosingElementType) const; 05778 05779 05780 static CElement * 05781 s_construct (void); 05782 05783 static void 05784 s_decodeFields ( 05785 CDecoderStream * pDecoderStream, 05786 CElement * pElement); 05788 05789 05790 05791 protected: 05792 CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID; 05793 05794 public: 05796 inline CImpinjEnableSerializedTID * 05797 getImpinjEnableSerializedTID (void) 05798 { 05799 return m_pImpinjEnableSerializedTID; 05800 } 05801 05803 EResultCode 05804 setImpinjEnableSerializedTID ( 05805 CImpinjEnableSerializedTID * pValue); 05806 05807 05808 protected: 05809 CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle; 05810 05811 public: 05813 inline CImpinjEnableRFPhaseAngle * 05814 getImpinjEnableRFPhaseAngle (void) 05815 { 05816 return m_pImpinjEnableRFPhaseAngle; 05817 } 05818 05820 EResultCode 05821 setImpinjEnableRFPhaseAngle ( 05822 CImpinjEnableRFPhaseAngle * pValue); 05823 05824 05825 protected: 05826 CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI; 05827 05828 public: 05830 inline CImpinjEnablePeakRSSI * 05831 getImpinjEnablePeakRSSI (void) 05832 { 05833 return m_pImpinjEnablePeakRSSI; 05834 } 05835 05837 EResultCode 05838 setImpinjEnablePeakRSSI ( 05839 CImpinjEnablePeakRSSI * pValue); 05840 05841 05842 protected: 05843 CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates; 05844 05845 public: 05847 inline CImpinjEnableGPSCoordinates * 05848 getImpinjEnableGPSCoordinates (void) 05849 { 05850 return m_pImpinjEnableGPSCoordinates; 05851 } 05852 05854 EResultCode 05855 setImpinjEnableGPSCoordinates ( 05856 CImpinjEnableGPSCoordinates * pValue); 05857 05858 05859 protected: 05860 CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead; 05861 05862 public: 05864 inline CImpinjEnableOptimizedRead * 05865 getImpinjEnableOptimizedRead (void) 05866 { 05867 return m_pImpinjEnableOptimizedRead; 05868 } 05869 05871 EResultCode 05872 setImpinjEnableOptimizedRead ( 05873 CImpinjEnableOptimizedRead * pValue); 05874 05875 05876 protected: 05877 CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency; 05878 05879 public: 05881 inline CImpinjEnableRFDopplerFrequency * 05882 getImpinjEnableRFDopplerFrequency (void) 05883 { 05884 return m_pImpinjEnableRFDopplerFrequency; 05885 } 05886 05888 EResultCode 05889 setImpinjEnableRFDopplerFrequency ( 05890 CImpinjEnableRFDopplerFrequency * pValue); 05891 05892 05893 protected: 05894 std::list<CParameter *> m_listCustom; 05895 05896 public: 05898 inline std::list<CParameter *>::iterator 05899 beginCustom (void) 05900 { 05901 return m_listCustom.begin(); 05902 } 05903 05905 inline std::list<CParameter *>::iterator 05906 endCustom (void) 05907 { 05908 return m_listCustom.end(); 05909 } 05910 05912 inline void 05913 clearCustom (void) 05914 { 05915 clearSubParameterList ((tListOfParameters *) &m_listCustom); 05916 } 05917 05919 inline int 05920 countCustom (void) 05921 { 05922 return (int) (m_listCustom.size()); 05923 } 05924 05925 EResultCode 05927 addCustom ( 05928 CParameter * pValue); 05929 05930 05931 }; 05932 05933 05957 class CImpinjEnableSerializedTID : public CParameter 05958 { 05959 public: 05960 CImpinjEnableSerializedTID (void); 05961 ~CImpinjEnableSerializedTID (void); 05962 05965 05966 static const CFieldDescriptor * const 05967 s_apFieldDescriptorTable[]; 05968 05969 static const CTypeDescriptor 05970 s_typeDescriptor; 05971 05972 void 05973 decodeFields ( 05974 CDecoderStream * pDecoderStream); 05975 05976 void 05977 assimilateSubParameters ( 05978 CErrorDetails * pError); 05979 05980 void 05981 encode ( 05982 CEncoderStream * pEncoderStream) const; 05983 05984 05985 llrp_bool_t 05986 isAllowedIn ( 05987 const CTypeDescriptor * pEnclosingElementType) const; 05988 05989 05990 static CElement * 05991 s_construct (void); 05992 05993 static void 05994 s_decodeFields ( 05995 CDecoderStream * pDecoderStream, 05996 CElement * pElement); 05998 05999 06000 protected: 06001 EImpinjSerializedTIDMode m_eSerializedTIDMode; 06002 06005 public: 06006 static const CFieldDescriptor 06007 s_fdSerializedTIDMode; 06009 06011 inline EImpinjSerializedTIDMode 06012 getSerializedTIDMode (void) 06013 { 06014 return m_eSerializedTIDMode; 06015 } 06016 06018 inline void 06019 setSerializedTIDMode ( 06020 EImpinjSerializedTIDMode value) 06021 { 06022 m_eSerializedTIDMode = value; 06023 } 06024 06025 06026 06027 protected: 06028 std::list<CParameter *> m_listCustom; 06029 06030 public: 06032 inline std::list<CParameter *>::iterator 06033 beginCustom (void) 06034 { 06035 return m_listCustom.begin(); 06036 } 06037 06039 inline std::list<CParameter *>::iterator 06040 endCustom (void) 06041 { 06042 return m_listCustom.end(); 06043 } 06044 06046 inline void 06047 clearCustom (void) 06048 { 06049 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06050 } 06051 06053 inline int 06054 countCustom (void) 06055 { 06056 return (int) (m_listCustom.size()); 06057 } 06058 06059 EResultCode 06061 addCustom ( 06062 CParameter * pValue); 06063 06064 06065 }; 06066 06067 06091 class CImpinjEnableRFPhaseAngle : public CParameter 06092 { 06093 public: 06094 CImpinjEnableRFPhaseAngle (void); 06095 ~CImpinjEnableRFPhaseAngle (void); 06096 06099 06100 static const CFieldDescriptor * const 06101 s_apFieldDescriptorTable[]; 06102 06103 static const CTypeDescriptor 06104 s_typeDescriptor; 06105 06106 void 06107 decodeFields ( 06108 CDecoderStream * pDecoderStream); 06109 06110 void 06111 assimilateSubParameters ( 06112 CErrorDetails * pError); 06113 06114 void 06115 encode ( 06116 CEncoderStream * pEncoderStream) const; 06117 06118 06119 llrp_bool_t 06120 isAllowedIn ( 06121 const CTypeDescriptor * pEnclosingElementType) const; 06122 06123 06124 static CElement * 06125 s_construct (void); 06126 06127 static void 06128 s_decodeFields ( 06129 CDecoderStream * pDecoderStream, 06130 CElement * pElement); 06132 06133 06134 protected: 06135 EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode; 06136 06139 public: 06140 static const CFieldDescriptor 06141 s_fdRFPhaseAngleMode; 06143 06145 inline EImpinjRFPhaseAngleMode 06146 getRFPhaseAngleMode (void) 06147 { 06148 return m_eRFPhaseAngleMode; 06149 } 06150 06152 inline void 06153 setRFPhaseAngleMode ( 06154 EImpinjRFPhaseAngleMode value) 06155 { 06156 m_eRFPhaseAngleMode = value; 06157 } 06158 06159 06160 06161 protected: 06162 std::list<CParameter *> m_listCustom; 06163 06164 public: 06166 inline std::list<CParameter *>::iterator 06167 beginCustom (void) 06168 { 06169 return m_listCustom.begin(); 06170 } 06171 06173 inline std::list<CParameter *>::iterator 06174 endCustom (void) 06175 { 06176 return m_listCustom.end(); 06177 } 06178 06180 inline void 06181 clearCustom (void) 06182 { 06183 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06184 } 06185 06187 inline int 06188 countCustom (void) 06189 { 06190 return (int) (m_listCustom.size()); 06191 } 06192 06193 EResultCode 06195 addCustom ( 06196 CParameter * pValue); 06197 06198 06199 }; 06200 06201 06225 class CImpinjEnablePeakRSSI : public CParameter 06226 { 06227 public: 06228 CImpinjEnablePeakRSSI (void); 06229 ~CImpinjEnablePeakRSSI (void); 06230 06233 06234 static const CFieldDescriptor * const 06235 s_apFieldDescriptorTable[]; 06236 06237 static const CTypeDescriptor 06238 s_typeDescriptor; 06239 06240 void 06241 decodeFields ( 06242 CDecoderStream * pDecoderStream); 06243 06244 void 06245 assimilateSubParameters ( 06246 CErrorDetails * pError); 06247 06248 void 06249 encode ( 06250 CEncoderStream * pEncoderStream) const; 06251 06252 06253 llrp_bool_t 06254 isAllowedIn ( 06255 const CTypeDescriptor * pEnclosingElementType) const; 06256 06257 06258 static CElement * 06259 s_construct (void); 06260 06261 static void 06262 s_decodeFields ( 06263 CDecoderStream * pDecoderStream, 06264 CElement * pElement); 06266 06267 06268 protected: 06269 EImpinjPeakRSSIMode m_ePeakRSSIMode; 06270 06273 public: 06274 static const CFieldDescriptor 06275 s_fdPeakRSSIMode; 06277 06279 inline EImpinjPeakRSSIMode 06280 getPeakRSSIMode (void) 06281 { 06282 return m_ePeakRSSIMode; 06283 } 06284 06286 inline void 06287 setPeakRSSIMode ( 06288 EImpinjPeakRSSIMode value) 06289 { 06290 m_ePeakRSSIMode = value; 06291 } 06292 06293 06294 06295 protected: 06296 std::list<CParameter *> m_listCustom; 06297 06298 public: 06300 inline std::list<CParameter *>::iterator 06301 beginCustom (void) 06302 { 06303 return m_listCustom.begin(); 06304 } 06305 06307 inline std::list<CParameter *>::iterator 06308 endCustom (void) 06309 { 06310 return m_listCustom.end(); 06311 } 06312 06314 inline void 06315 clearCustom (void) 06316 { 06317 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06318 } 06319 06321 inline int 06322 countCustom (void) 06323 { 06324 return (int) (m_listCustom.size()); 06325 } 06326 06327 EResultCode 06329 addCustom ( 06330 CParameter * pValue); 06331 06332 06333 }; 06334 06335 06359 class CImpinjEnableGPSCoordinates : public CParameter 06360 { 06361 public: 06362 CImpinjEnableGPSCoordinates (void); 06363 ~CImpinjEnableGPSCoordinates (void); 06364 06367 06368 static const CFieldDescriptor * const 06369 s_apFieldDescriptorTable[]; 06370 06371 static const CTypeDescriptor 06372 s_typeDescriptor; 06373 06374 void 06375 decodeFields ( 06376 CDecoderStream * pDecoderStream); 06377 06378 void 06379 assimilateSubParameters ( 06380 CErrorDetails * pError); 06381 06382 void 06383 encode ( 06384 CEncoderStream * pEncoderStream) const; 06385 06386 06387 llrp_bool_t 06388 isAllowedIn ( 06389 const CTypeDescriptor * pEnclosingElementType) const; 06390 06391 06392 static CElement * 06393 s_construct (void); 06394 06395 static void 06396 s_decodeFields ( 06397 CDecoderStream * pDecoderStream, 06398 CElement * pElement); 06400 06401 06402 protected: 06403 EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode; 06404 06407 public: 06408 static const CFieldDescriptor 06409 s_fdGPSCoordinatesMode; 06411 06413 inline EImpinjGPSCoordinatesMode 06414 getGPSCoordinatesMode (void) 06415 { 06416 return m_eGPSCoordinatesMode; 06417 } 06418 06420 inline void 06421 setGPSCoordinatesMode ( 06422 EImpinjGPSCoordinatesMode value) 06423 { 06424 m_eGPSCoordinatesMode = value; 06425 } 06426 06427 06428 06429 protected: 06430 std::list<CParameter *> m_listCustom; 06431 06432 public: 06434 inline std::list<CParameter *>::iterator 06435 beginCustom (void) 06436 { 06437 return m_listCustom.begin(); 06438 } 06439 06441 inline std::list<CParameter *>::iterator 06442 endCustom (void) 06443 { 06444 return m_listCustom.end(); 06445 } 06446 06448 inline void 06449 clearCustom (void) 06450 { 06451 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06452 } 06453 06455 inline int 06456 countCustom (void) 06457 { 06458 return (int) (m_listCustom.size()); 06459 } 06460 06461 EResultCode 06463 addCustom ( 06464 CParameter * pValue); 06465 06466 06467 }; 06468 06469 06495 class CImpinjSerializedTID : public CParameter 06496 { 06497 public: 06498 CImpinjSerializedTID (void); 06499 ~CImpinjSerializedTID (void); 06500 06503 06504 static const CFieldDescriptor * const 06505 s_apFieldDescriptorTable[]; 06506 06507 static const CTypeDescriptor 06508 s_typeDescriptor; 06509 06510 void 06511 decodeFields ( 06512 CDecoderStream * pDecoderStream); 06513 06514 void 06515 assimilateSubParameters ( 06516 CErrorDetails * pError); 06517 06518 void 06519 encode ( 06520 CEncoderStream * pEncoderStream) const; 06521 06522 06523 llrp_bool_t 06524 isAllowedIn ( 06525 const CTypeDescriptor * pEnclosingElementType) const; 06526 06527 06528 static CElement * 06529 s_construct (void); 06530 06531 static void 06532 s_decodeFields ( 06533 CDecoderStream * pDecoderStream, 06534 CElement * pElement); 06536 06537 06538 protected: 06539 llrp_u16v_t m_TID; 06540 06543 public: 06544 static const CFieldDescriptor 06545 s_fdTID; 06547 06549 inline llrp_u16v_t 06550 getTID (void) 06551 { 06552 return m_TID; 06553 } 06554 06556 inline void 06557 setTID ( 06558 llrp_u16v_t value) 06559 { 06560 m_TID = value; 06561 } 06562 06563 06564 06565 protected: 06566 CImpinjTIDParity * m_pImpinjTIDParity; 06567 06568 public: 06570 inline CImpinjTIDParity * 06571 getImpinjTIDParity (void) 06572 { 06573 return m_pImpinjTIDParity; 06574 } 06575 06577 EResultCode 06578 setImpinjTIDParity ( 06579 CImpinjTIDParity * pValue); 06580 06581 06582 protected: 06583 std::list<CParameter *> m_listCustom; 06584 06585 public: 06587 inline std::list<CParameter *>::iterator 06588 beginCustom (void) 06589 { 06590 return m_listCustom.begin(); 06591 } 06592 06594 inline std::list<CParameter *>::iterator 06595 endCustom (void) 06596 { 06597 return m_listCustom.end(); 06598 } 06599 06601 inline void 06602 clearCustom (void) 06603 { 06604 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06605 } 06606 06608 inline int 06609 countCustom (void) 06610 { 06611 return (int) (m_listCustom.size()); 06612 } 06613 06614 EResultCode 06616 addCustom ( 06617 CParameter * pValue); 06618 06619 06620 }; 06621 06622 06647 class CImpinjRFPhaseAngle : public CParameter 06648 { 06649 public: 06650 CImpinjRFPhaseAngle (void); 06651 ~CImpinjRFPhaseAngle (void); 06652 06655 06656 static const CFieldDescriptor * const 06657 s_apFieldDescriptorTable[]; 06658 06659 static const CTypeDescriptor 06660 s_typeDescriptor; 06661 06662 void 06663 decodeFields ( 06664 CDecoderStream * pDecoderStream); 06665 06666 void 06667 assimilateSubParameters ( 06668 CErrorDetails * pError); 06669 06670 void 06671 encode ( 06672 CEncoderStream * pEncoderStream) const; 06673 06674 06675 llrp_bool_t 06676 isAllowedIn ( 06677 const CTypeDescriptor * pEnclosingElementType) const; 06678 06679 06680 static CElement * 06681 s_construct (void); 06682 06683 static void 06684 s_decodeFields ( 06685 CDecoderStream * pDecoderStream, 06686 CElement * pElement); 06688 06689 06690 protected: 06691 llrp_u16_t m_PhaseAngle; 06692 06695 public: 06696 static const CFieldDescriptor 06697 s_fdPhaseAngle; 06699 06701 inline llrp_u16_t 06702 getPhaseAngle (void) 06703 { 06704 return m_PhaseAngle; 06705 } 06706 06708 inline void 06709 setPhaseAngle ( 06710 llrp_u16_t value) 06711 { 06712 m_PhaseAngle = value; 06713 } 06714 06715 06716 06717 protected: 06718 std::list<CParameter *> m_listCustom; 06719 06720 public: 06722 inline std::list<CParameter *>::iterator 06723 beginCustom (void) 06724 { 06725 return m_listCustom.begin(); 06726 } 06727 06729 inline std::list<CParameter *>::iterator 06730 endCustom (void) 06731 { 06732 return m_listCustom.end(); 06733 } 06734 06736 inline void 06737 clearCustom (void) 06738 { 06739 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06740 } 06741 06743 inline int 06744 countCustom (void) 06745 { 06746 return (int) (m_listCustom.size()); 06747 } 06748 06749 EResultCode 06751 addCustom ( 06752 CParameter * pValue); 06753 06754 06755 }; 06756 06757 06782 class CImpinjPeakRSSI : public CParameter 06783 { 06784 public: 06785 CImpinjPeakRSSI (void); 06786 ~CImpinjPeakRSSI (void); 06787 06790 06791 static const CFieldDescriptor * const 06792 s_apFieldDescriptorTable[]; 06793 06794 static const CTypeDescriptor 06795 s_typeDescriptor; 06796 06797 void 06798 decodeFields ( 06799 CDecoderStream * pDecoderStream); 06800 06801 void 06802 assimilateSubParameters ( 06803 CErrorDetails * pError); 06804 06805 void 06806 encode ( 06807 CEncoderStream * pEncoderStream) const; 06808 06809 06810 llrp_bool_t 06811 isAllowedIn ( 06812 const CTypeDescriptor * pEnclosingElementType) const; 06813 06814 06815 static CElement * 06816 s_construct (void); 06817 06818 static void 06819 s_decodeFields ( 06820 CDecoderStream * pDecoderStream, 06821 CElement * pElement); 06823 06824 06825 protected: 06826 llrp_s16_t m_RSSI; 06827 06830 public: 06831 static const CFieldDescriptor 06832 s_fdRSSI; 06834 06836 inline llrp_s16_t 06837 getRSSI (void) 06838 { 06839 return m_RSSI; 06840 } 06841 06843 inline void 06844 setRSSI ( 06845 llrp_s16_t value) 06846 { 06847 m_RSSI = value; 06848 } 06849 06850 06851 06852 protected: 06853 std::list<CParameter *> m_listCustom; 06854 06855 public: 06857 inline std::list<CParameter *>::iterator 06858 beginCustom (void) 06859 { 06860 return m_listCustom.begin(); 06861 } 06862 06864 inline std::list<CParameter *>::iterator 06865 endCustom (void) 06866 { 06867 return m_listCustom.end(); 06868 } 06869 06871 inline void 06872 clearCustom (void) 06873 { 06874 clearSubParameterList ((tListOfParameters *) &m_listCustom); 06875 } 06876 06878 inline int 06879 countCustom (void) 06880 { 06881 return (int) (m_listCustom.size()); 06882 } 06883 06884 EResultCode 06886 addCustom ( 06887 CParameter * pValue); 06888 06889 06890 }; 06891 06892 06918 class CImpinjGPSCoordinates : public CParameter 06919 { 06920 public: 06921 CImpinjGPSCoordinates (void); 06922 ~CImpinjGPSCoordinates (void); 06923 06926 06927 static const CFieldDescriptor * const 06928 s_apFieldDescriptorTable[]; 06929 06930 static const CTypeDescriptor 06931 s_typeDescriptor; 06932 06933 void 06934 decodeFields ( 06935 CDecoderStream * pDecoderStream); 06936 06937 void 06938 assimilateSubParameters ( 06939 CErrorDetails * pError); 06940 06941 void 06942 encode ( 06943 CEncoderStream * pEncoderStream) const; 06944 06945 06946 llrp_bool_t 06947 isAllowedIn ( 06948 const CTypeDescriptor * pEnclosingElementType) const; 06949 06950 06951 static CElement * 06952 s_construct (void); 06953 06954 static void 06955 s_decodeFields ( 06956 CDecoderStream * pDecoderStream, 06957 CElement * pElement); 06959 06960 06961 protected: 06962 llrp_s32_t m_Latitude; 06963 06966 public: 06967 static const CFieldDescriptor 06968 s_fdLatitude; 06970 06972 inline llrp_s32_t 06973 getLatitude (void) 06974 { 06975 return m_Latitude; 06976 } 06977 06979 inline void 06980 setLatitude ( 06981 llrp_s32_t value) 06982 { 06983 m_Latitude = value; 06984 } 06985 06986 06987 protected: 06988 llrp_s32_t m_Longitude; 06989 06992 public: 06993 static const CFieldDescriptor 06994 s_fdLongitude; 06996 06998 inline llrp_s32_t 06999 getLongitude (void) 07000 { 07001 return m_Longitude; 07002 } 07003 07005 inline void 07006 setLongitude ( 07007 llrp_s32_t value) 07008 { 07009 m_Longitude = value; 07010 } 07011 07012 07013 07014 protected: 07015 std::list<CParameter *> m_listCustom; 07016 07017 public: 07019 inline std::list<CParameter *>::iterator 07020 beginCustom (void) 07021 { 07022 return m_listCustom.begin(); 07023 } 07024 07026 inline std::list<CParameter *>::iterator 07027 endCustom (void) 07028 { 07029 return m_listCustom.end(); 07030 } 07031 07033 inline void 07034 clearCustom (void) 07035 { 07036 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07037 } 07038 07040 inline int 07041 countCustom (void) 07042 { 07043 return (int) (m_listCustom.size()); 07044 } 07045 07046 EResultCode 07048 addCustom ( 07049 CParameter * pValue); 07050 07051 07052 }; 07053 07054 07079 class CImpinjLoopSpec : public CParameter 07080 { 07081 public: 07082 CImpinjLoopSpec (void); 07083 ~CImpinjLoopSpec (void); 07084 07087 07088 static const CFieldDescriptor * const 07089 s_apFieldDescriptorTable[]; 07090 07091 static const CTypeDescriptor 07092 s_typeDescriptor; 07093 07094 void 07095 decodeFields ( 07096 CDecoderStream * pDecoderStream); 07097 07098 void 07099 assimilateSubParameters ( 07100 CErrorDetails * pError); 07101 07102 void 07103 encode ( 07104 CEncoderStream * pEncoderStream) const; 07105 07106 07107 llrp_bool_t 07108 isAllowedIn ( 07109 const CTypeDescriptor * pEnclosingElementType) const; 07110 07111 07112 static CElement * 07113 s_construct (void); 07114 07115 static void 07116 s_decodeFields ( 07117 CDecoderStream * pDecoderStream, 07118 CElement * pElement); 07120 07121 07122 protected: 07123 llrp_u32_t m_LoopCount; 07124 07127 public: 07128 static const CFieldDescriptor 07129 s_fdLoopCount; 07131 07133 inline llrp_u32_t 07134 getLoopCount (void) 07135 { 07136 return m_LoopCount; 07137 } 07138 07140 inline void 07141 setLoopCount ( 07142 llrp_u32_t value) 07143 { 07144 m_LoopCount = value; 07145 } 07146 07147 07148 07149 protected: 07150 std::list<CParameter *> m_listCustom; 07151 07152 public: 07154 inline std::list<CParameter *>::iterator 07155 beginCustom (void) 07156 { 07157 return m_listCustom.begin(); 07158 } 07159 07161 inline std::list<CParameter *>::iterator 07162 endCustom (void) 07163 { 07164 return m_listCustom.end(); 07165 } 07166 07168 inline void 07169 clearCustom (void) 07170 { 07171 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07172 } 07173 07175 inline int 07176 countCustom (void) 07177 { 07178 return (int) (m_listCustom.size()); 07179 } 07180 07181 EResultCode 07183 addCustom ( 07184 CParameter * pValue); 07185 07186 07187 }; 07188 07189 07215 class CImpinjGPSNMEASentences : public CParameter 07216 { 07217 public: 07218 CImpinjGPSNMEASentences (void); 07219 ~CImpinjGPSNMEASentences (void); 07220 07223 07224 static const CFieldDescriptor * const 07225 s_apFieldDescriptorTable[]; 07226 07227 static const CTypeDescriptor 07228 s_typeDescriptor; 07229 07230 void 07231 decodeFields ( 07232 CDecoderStream * pDecoderStream); 07233 07234 void 07235 assimilateSubParameters ( 07236 CErrorDetails * pError); 07237 07238 void 07239 encode ( 07240 CEncoderStream * pEncoderStream) const; 07241 07242 07243 llrp_bool_t 07244 isAllowedIn ( 07245 const CTypeDescriptor * pEnclosingElementType) const; 07246 07247 07248 static CElement * 07249 s_construct (void); 07250 07251 static void 07252 s_decodeFields ( 07253 CDecoderStream * pDecoderStream, 07254 CElement * pElement); 07256 07257 07258 07259 protected: 07260 CImpinjGGASentence * m_pImpinjGGASentence; 07261 07262 public: 07264 inline CImpinjGGASentence * 07265 getImpinjGGASentence (void) 07266 { 07267 return m_pImpinjGGASentence; 07268 } 07269 07271 EResultCode 07272 setImpinjGGASentence ( 07273 CImpinjGGASentence * pValue); 07274 07275 07276 protected: 07277 CImpinjRMCSentence * m_pImpinjRMCSentence; 07278 07279 public: 07281 inline CImpinjRMCSentence * 07282 getImpinjRMCSentence (void) 07283 { 07284 return m_pImpinjRMCSentence; 07285 } 07286 07288 EResultCode 07289 setImpinjRMCSentence ( 07290 CImpinjRMCSentence * pValue); 07291 07292 07293 protected: 07294 std::list<CParameter *> m_listCustom; 07295 07296 public: 07298 inline std::list<CParameter *>::iterator 07299 beginCustom (void) 07300 { 07301 return m_listCustom.begin(); 07302 } 07303 07305 inline std::list<CParameter *>::iterator 07306 endCustom (void) 07307 { 07308 return m_listCustom.end(); 07309 } 07310 07312 inline void 07313 clearCustom (void) 07314 { 07315 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07316 } 07317 07319 inline int 07320 countCustom (void) 07321 { 07322 return (int) (m_listCustom.size()); 07323 } 07324 07325 EResultCode 07327 addCustom ( 07328 CParameter * pValue); 07329 07330 07331 }; 07332 07333 07357 class CImpinjGGASentence : public CParameter 07358 { 07359 public: 07360 CImpinjGGASentence (void); 07361 ~CImpinjGGASentence (void); 07362 07365 07366 static const CFieldDescriptor * const 07367 s_apFieldDescriptorTable[]; 07368 07369 static const CTypeDescriptor 07370 s_typeDescriptor; 07371 07372 void 07373 decodeFields ( 07374 CDecoderStream * pDecoderStream); 07375 07376 void 07377 assimilateSubParameters ( 07378 CErrorDetails * pError); 07379 07380 void 07381 encode ( 07382 CEncoderStream * pEncoderStream) const; 07383 07384 07385 llrp_bool_t 07386 isAllowedIn ( 07387 const CTypeDescriptor * pEnclosingElementType) const; 07388 07389 07390 static CElement * 07391 s_construct (void); 07392 07393 static void 07394 s_decodeFields ( 07395 CDecoderStream * pDecoderStream, 07396 CElement * pElement); 07398 07399 07400 protected: 07401 llrp_utf8v_t m_GGASentence; 07402 07405 public: 07406 static const CFieldDescriptor 07407 s_fdGGASentence; 07409 07411 inline llrp_utf8v_t 07412 getGGASentence (void) 07413 { 07414 return m_GGASentence; 07415 } 07416 07418 inline void 07419 setGGASentence ( 07420 llrp_utf8v_t value) 07421 { 07422 m_GGASentence = value; 07423 } 07424 07425 07426 07427 protected: 07428 std::list<CParameter *> m_listCustom; 07429 07430 public: 07432 inline std::list<CParameter *>::iterator 07433 beginCustom (void) 07434 { 07435 return m_listCustom.begin(); 07436 } 07437 07439 inline std::list<CParameter *>::iterator 07440 endCustom (void) 07441 { 07442 return m_listCustom.end(); 07443 } 07444 07446 inline void 07447 clearCustom (void) 07448 { 07449 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07450 } 07451 07453 inline int 07454 countCustom (void) 07455 { 07456 return (int) (m_listCustom.size()); 07457 } 07458 07459 EResultCode 07461 addCustom ( 07462 CParameter * pValue); 07463 07464 07465 }; 07466 07467 07491 class CImpinjRMCSentence : public CParameter 07492 { 07493 public: 07494 CImpinjRMCSentence (void); 07495 ~CImpinjRMCSentence (void); 07496 07499 07500 static const CFieldDescriptor * const 07501 s_apFieldDescriptorTable[]; 07502 07503 static const CTypeDescriptor 07504 s_typeDescriptor; 07505 07506 void 07507 decodeFields ( 07508 CDecoderStream * pDecoderStream); 07509 07510 void 07511 assimilateSubParameters ( 07512 CErrorDetails * pError); 07513 07514 void 07515 encode ( 07516 CEncoderStream * pEncoderStream) const; 07517 07518 07519 llrp_bool_t 07520 isAllowedIn ( 07521 const CTypeDescriptor * pEnclosingElementType) const; 07522 07523 07524 static CElement * 07525 s_construct (void); 07526 07527 static void 07528 s_decodeFields ( 07529 CDecoderStream * pDecoderStream, 07530 CElement * pElement); 07532 07533 07534 protected: 07535 llrp_utf8v_t m_RMCSentence; 07536 07539 public: 07540 static const CFieldDescriptor 07541 s_fdRMCSentence; 07543 07545 inline llrp_utf8v_t 07546 getRMCSentence (void) 07547 { 07548 return m_RMCSentence; 07549 } 07550 07552 inline void 07553 setRMCSentence ( 07554 llrp_utf8v_t value) 07555 { 07556 m_RMCSentence = value; 07557 } 07558 07559 07560 07561 protected: 07562 std::list<CParameter *> m_listCustom; 07563 07564 public: 07566 inline std::list<CParameter *>::iterator 07567 beginCustom (void) 07568 { 07569 return m_listCustom.begin(); 07570 } 07571 07573 inline std::list<CParameter *>::iterator 07574 endCustom (void) 07575 { 07576 return m_listCustom.end(); 07577 } 07578 07580 inline void 07581 clearCustom (void) 07582 { 07583 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07584 } 07585 07587 inline int 07588 countCustom (void) 07589 { 07590 return (int) (m_listCustom.size()); 07591 } 07592 07593 EResultCode 07595 addCustom ( 07596 CParameter * pValue); 07597 07598 07599 }; 07600 07601 07625 class CImpinjOpSpecRetryCount : public CParameter 07626 { 07627 public: 07628 CImpinjOpSpecRetryCount (void); 07629 ~CImpinjOpSpecRetryCount (void); 07630 07633 07634 static const CFieldDescriptor * const 07635 s_apFieldDescriptorTable[]; 07636 07637 static const CTypeDescriptor 07638 s_typeDescriptor; 07639 07640 void 07641 decodeFields ( 07642 CDecoderStream * pDecoderStream); 07643 07644 void 07645 assimilateSubParameters ( 07646 CErrorDetails * pError); 07647 07648 void 07649 encode ( 07650 CEncoderStream * pEncoderStream) const; 07651 07652 07653 llrp_bool_t 07654 isAllowedIn ( 07655 const CTypeDescriptor * pEnclosingElementType) const; 07656 07657 07658 static CElement * 07659 s_construct (void); 07660 07661 static void 07662 s_decodeFields ( 07663 CDecoderStream * pDecoderStream, 07664 CElement * pElement); 07666 07667 07668 protected: 07669 llrp_u16_t m_RetryCount; 07670 07673 public: 07674 static const CFieldDescriptor 07675 s_fdRetryCount; 07677 07679 inline llrp_u16_t 07680 getRetryCount (void) 07681 { 07682 return m_RetryCount; 07683 } 07684 07686 inline void 07687 setRetryCount ( 07688 llrp_u16_t value) 07689 { 07690 m_RetryCount = value; 07691 } 07692 07693 07694 07695 protected: 07696 std::list<CParameter *> m_listCustom; 07697 07698 public: 07700 inline std::list<CParameter *>::iterator 07701 beginCustom (void) 07702 { 07703 return m_listCustom.begin(); 07704 } 07705 07707 inline std::list<CParameter *>::iterator 07708 endCustom (void) 07709 { 07710 return m_listCustom.end(); 07711 } 07712 07714 inline void 07715 clearCustom (void) 07716 { 07717 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07718 } 07719 07721 inline int 07722 countCustom (void) 07723 { 07724 return (int) (m_listCustom.size()); 07725 } 07726 07727 EResultCode 07729 addCustom ( 07730 CParameter * pValue); 07731 07732 07733 }; 07734 07735 07763 class CImpinjAdvancedGPOConfiguration : public CParameter 07764 { 07765 public: 07766 CImpinjAdvancedGPOConfiguration (void); 07767 ~CImpinjAdvancedGPOConfiguration (void); 07768 07771 07772 static const CFieldDescriptor * const 07773 s_apFieldDescriptorTable[]; 07774 07775 static const CTypeDescriptor 07776 s_typeDescriptor; 07777 07778 void 07779 decodeFields ( 07780 CDecoderStream * pDecoderStream); 07781 07782 void 07783 assimilateSubParameters ( 07784 CErrorDetails * pError); 07785 07786 void 07787 encode ( 07788 CEncoderStream * pEncoderStream) const; 07789 07790 07791 llrp_bool_t 07792 isAllowedIn ( 07793 const CTypeDescriptor * pEnclosingElementType) const; 07794 07795 07796 static CElement * 07797 s_construct (void); 07798 07799 static void 07800 s_decodeFields ( 07801 CDecoderStream * pDecoderStream, 07802 CElement * pElement); 07804 07805 07806 protected: 07807 llrp_u16_t m_GPOPortNum; 07808 07811 public: 07812 static const CFieldDescriptor 07813 s_fdGPOPortNum; 07815 07817 inline llrp_u16_t 07818 getGPOPortNum (void) 07819 { 07820 return m_GPOPortNum; 07821 } 07822 07824 inline void 07825 setGPOPortNum ( 07826 llrp_u16_t value) 07827 { 07828 m_GPOPortNum = value; 07829 } 07830 07831 07832 protected: 07833 EImpinjAdvancedGPOMode m_eGPOMode; 07834 07837 public: 07838 static const CFieldDescriptor 07839 s_fdGPOMode; 07841 07843 inline EImpinjAdvancedGPOMode 07844 getGPOMode (void) 07845 { 07846 return m_eGPOMode; 07847 } 07848 07850 inline void 07851 setGPOMode ( 07852 EImpinjAdvancedGPOMode value) 07853 { 07854 m_eGPOMode = value; 07855 } 07856 07857 07858 protected: 07859 llrp_u32_t m_GPOPulseDurationMSec; 07860 07863 public: 07864 static const CFieldDescriptor 07865 s_fdGPOPulseDurationMSec; 07867 07869 inline llrp_u32_t 07870 getGPOPulseDurationMSec (void) 07871 { 07872 return m_GPOPulseDurationMSec; 07873 } 07874 07876 inline void 07877 setGPOPulseDurationMSec ( 07878 llrp_u32_t value) 07879 { 07880 m_GPOPulseDurationMSec = value; 07881 } 07882 07883 07884 07885 protected: 07886 std::list<CParameter *> m_listCustom; 07887 07888 public: 07890 inline std::list<CParameter *>::iterator 07891 beginCustom (void) 07892 { 07893 return m_listCustom.begin(); 07894 } 07895 07897 inline std::list<CParameter *>::iterator 07898 endCustom (void) 07899 { 07900 return m_listCustom.end(); 07901 } 07902 07904 inline void 07905 clearCustom (void) 07906 { 07907 clearSubParameterList ((tListOfParameters *) &m_listCustom); 07908 } 07909 07911 inline int 07912 countCustom (void) 07913 { 07914 return (int) (m_listCustom.size()); 07915 } 07916 07917 EResultCode 07919 addCustom ( 07920 CParameter * pValue); 07921 07922 07923 }; 07924 07925 07959 class CImpinjEnableOptimizedRead : public CParameter 07960 { 07961 public: 07962 CImpinjEnableOptimizedRead (void); 07963 ~CImpinjEnableOptimizedRead (void); 07964 07967 07968 static const CFieldDescriptor * const 07969 s_apFieldDescriptorTable[]; 07970 07971 static const CTypeDescriptor 07972 s_typeDescriptor; 07973 07974 void 07975 decodeFields ( 07976 CDecoderStream * pDecoderStream); 07977 07978 void 07979 assimilateSubParameters ( 07980 CErrorDetails * pError); 07981 07982 void 07983 encode ( 07984 CEncoderStream * pEncoderStream) const; 07985 07986 07987 llrp_bool_t 07988 isAllowedIn ( 07989 const CTypeDescriptor * pEnclosingElementType) const; 07990 07991 07992 static CElement * 07993 s_construct (void); 07994 07995 static void 07996 s_decodeFields ( 07997 CDecoderStream * pDecoderStream, 07998 CElement * pElement); 08000 08001 08002 protected: 08003 EImpinjOptimizedReadMode m_eOptimizedReadMode; 08004 08007 public: 08008 static const CFieldDescriptor 08009 s_fdOptimizedReadMode; 08011 08013 inline EImpinjOptimizedReadMode 08014 getOptimizedReadMode (void) 08015 { 08016 return m_eOptimizedReadMode; 08017 } 08018 08020 inline void 08021 setOptimizedReadMode ( 08022 EImpinjOptimizedReadMode value) 08023 { 08024 m_eOptimizedReadMode = value; 08025 } 08026 08027 08028 08029 protected: 08030 std::list<CC1G2Read *> m_listC1G2Read; 08031 08032 public: 08034 inline std::list<CC1G2Read *>::iterator 08035 beginC1G2Read (void) 08036 { 08037 return m_listC1G2Read.begin(); 08038 } 08039 08041 inline std::list<CC1G2Read *>::iterator 08042 endC1G2Read (void) 08043 { 08044 return m_listC1G2Read.end(); 08045 } 08046 08048 inline void 08049 clearC1G2Read (void) 08050 { 08051 clearSubParameterList ((tListOfParameters *) &m_listC1G2Read); 08052 } 08053 08055 inline int 08056 countC1G2Read (void) 08057 { 08058 return (int) (m_listC1G2Read.size()); 08059 } 08060 08061 EResultCode 08063 addC1G2Read ( 08064 CC1G2Read * pValue); 08065 08066 08067 protected: 08068 std::list<CParameter *> m_listCustom; 08069 08070 public: 08072 inline std::list<CParameter *>::iterator 08073 beginCustom (void) 08074 { 08075 return m_listCustom.begin(); 08076 } 08077 08079 inline std::list<CParameter *>::iterator 08080 endCustom (void) 08081 { 08082 return m_listCustom.end(); 08083 } 08084 08086 inline void 08087 clearCustom (void) 08088 { 08089 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08090 } 08091 08093 inline int 08094 countCustom (void) 08095 { 08096 return (int) (m_listCustom.size()); 08097 } 08098 08099 EResultCode 08101 addCustom ( 08102 CParameter * pValue); 08103 08104 08105 }; 08106 08107 08134 class CImpinjAccessSpecOrdering : public CParameter 08135 { 08136 public: 08137 CImpinjAccessSpecOrdering (void); 08138 ~CImpinjAccessSpecOrdering (void); 08139 08142 08143 static const CFieldDescriptor * const 08144 s_apFieldDescriptorTable[]; 08145 08146 static const CTypeDescriptor 08147 s_typeDescriptor; 08148 08149 void 08150 decodeFields ( 08151 CDecoderStream * pDecoderStream); 08152 08153 void 08154 assimilateSubParameters ( 08155 CErrorDetails * pError); 08156 08157 void 08158 encode ( 08159 CEncoderStream * pEncoderStream) const; 08160 08161 08162 llrp_bool_t 08163 isAllowedIn ( 08164 const CTypeDescriptor * pEnclosingElementType) const; 08165 08166 08167 static CElement * 08168 s_construct (void); 08169 08170 static void 08171 s_decodeFields ( 08172 CDecoderStream * pDecoderStream, 08173 CElement * pElement); 08175 08176 08177 protected: 08178 EImpinjAccessSpecOrderingMode m_eOrderingMode; 08179 08182 public: 08183 static const CFieldDescriptor 08184 s_fdOrderingMode; 08186 08188 inline EImpinjAccessSpecOrderingMode 08189 getOrderingMode (void) 08190 { 08191 return m_eOrderingMode; 08192 } 08193 08195 inline void 08196 setOrderingMode ( 08197 EImpinjAccessSpecOrderingMode value) 08198 { 08199 m_eOrderingMode = value; 08200 } 08201 08202 08203 08204 protected: 08205 std::list<CParameter *> m_listCustom; 08206 08207 public: 08209 inline std::list<CParameter *>::iterator 08210 beginCustom (void) 08211 { 08212 return m_listCustom.begin(); 08213 } 08214 08216 inline std::list<CParameter *>::iterator 08217 endCustom (void) 08218 { 08219 return m_listCustom.end(); 08220 } 08221 08223 inline void 08224 clearCustom (void) 08225 { 08226 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08227 } 08228 08230 inline int 08231 countCustom (void) 08232 { 08233 return (int) (m_listCustom.size()); 08234 } 08235 08236 EResultCode 08238 addCustom ( 08239 CParameter * pValue); 08240 08241 08242 }; 08243 08244 08268 class CImpinjEnableRFDopplerFrequency : public CParameter 08269 { 08270 public: 08271 CImpinjEnableRFDopplerFrequency (void); 08272 ~CImpinjEnableRFDopplerFrequency (void); 08273 08276 08277 static const CFieldDescriptor * const 08278 s_apFieldDescriptorTable[]; 08279 08280 static const CTypeDescriptor 08281 s_typeDescriptor; 08282 08283 void 08284 decodeFields ( 08285 CDecoderStream * pDecoderStream); 08286 08287 void 08288 assimilateSubParameters ( 08289 CErrorDetails * pError); 08290 08291 void 08292 encode ( 08293 CEncoderStream * pEncoderStream) const; 08294 08295 08296 llrp_bool_t 08297 isAllowedIn ( 08298 const CTypeDescriptor * pEnclosingElementType) const; 08299 08300 08301 static CElement * 08302 s_construct (void); 08303 08304 static void 08305 s_decodeFields ( 08306 CDecoderStream * pDecoderStream, 08307 CElement * pElement); 08309 08310 08311 protected: 08312 EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode; 08313 08316 public: 08317 static const CFieldDescriptor 08318 s_fdRFDopplerFrequencyMode; 08320 08322 inline EImpinjRFDopplerFrequencyMode 08323 getRFDopplerFrequencyMode (void) 08324 { 08325 return m_eRFDopplerFrequencyMode; 08326 } 08327 08329 inline void 08330 setRFDopplerFrequencyMode ( 08331 EImpinjRFDopplerFrequencyMode value) 08332 { 08333 m_eRFDopplerFrequencyMode = value; 08334 } 08335 08336 08337 08338 protected: 08339 std::list<CParameter *> m_listCustom; 08340 08341 public: 08343 inline std::list<CParameter *>::iterator 08344 beginCustom (void) 08345 { 08346 return m_listCustom.begin(); 08347 } 08348 08350 inline std::list<CParameter *>::iterator 08351 endCustom (void) 08352 { 08353 return m_listCustom.end(); 08354 } 08355 08357 inline void 08358 clearCustom (void) 08359 { 08360 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08361 } 08362 08364 inline int 08365 countCustom (void) 08366 { 08367 return (int) (m_listCustom.size()); 08368 } 08369 08370 EResultCode 08372 addCustom ( 08373 CParameter * pValue); 08374 08375 08376 }; 08377 08378 08403 class CImpinjRFDopplerFrequency : public CParameter 08404 { 08405 public: 08406 CImpinjRFDopplerFrequency (void); 08407 ~CImpinjRFDopplerFrequency (void); 08408 08411 08412 static const CFieldDescriptor * const 08413 s_apFieldDescriptorTable[]; 08414 08415 static const CTypeDescriptor 08416 s_typeDescriptor; 08417 08418 void 08419 decodeFields ( 08420 CDecoderStream * pDecoderStream); 08421 08422 void 08423 assimilateSubParameters ( 08424 CErrorDetails * pError); 08425 08426 void 08427 encode ( 08428 CEncoderStream * pEncoderStream) const; 08429 08430 08431 llrp_bool_t 08432 isAllowedIn ( 08433 const CTypeDescriptor * pEnclosingElementType) const; 08434 08435 08436 static CElement * 08437 s_construct (void); 08438 08439 static void 08440 s_decodeFields ( 08441 CDecoderStream * pDecoderStream, 08442 CElement * pElement); 08444 08445 08446 protected: 08447 llrp_s16_t m_DopplerFrequency; 08448 08451 public: 08452 static const CFieldDescriptor 08453 s_fdDopplerFrequency; 08455 08457 inline llrp_s16_t 08458 getDopplerFrequency (void) 08459 { 08460 return m_DopplerFrequency; 08461 } 08462 08464 inline void 08465 setDopplerFrequency ( 08466 llrp_s16_t value) 08467 { 08468 m_DopplerFrequency = value; 08469 } 08470 08471 08472 08473 protected: 08474 std::list<CParameter *> m_listCustom; 08475 08476 public: 08478 inline std::list<CParameter *>::iterator 08479 beginCustom (void) 08480 { 08481 return m_listCustom.begin(); 08482 } 08483 08485 inline std::list<CParameter *>::iterator 08486 endCustom (void) 08487 { 08488 return m_listCustom.end(); 08489 } 08490 08492 inline void 08493 clearCustom (void) 08494 { 08495 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08496 } 08497 08499 inline int 08500 countCustom (void) 08501 { 08502 return (int) (m_listCustom.size()); 08503 } 08504 08505 EResultCode 08507 addCustom ( 08508 CParameter * pValue); 08509 08510 08511 }; 08512 08513 08546 class CImpinjInventoryConfiguration : public CParameter 08547 { 08548 public: 08549 CImpinjInventoryConfiguration (void); 08550 ~CImpinjInventoryConfiguration (void); 08551 08554 08555 static const CFieldDescriptor * const 08556 s_apFieldDescriptorTable[]; 08557 08558 static const CTypeDescriptor 08559 s_typeDescriptor; 08560 08561 void 08562 decodeFields ( 08563 CDecoderStream * pDecoderStream); 08564 08565 void 08566 assimilateSubParameters ( 08567 CErrorDetails * pError); 08568 08569 void 08570 encode ( 08571 CEncoderStream * pEncoderStream) const; 08572 08573 08574 llrp_bool_t 08575 isAllowedIn ( 08576 const CTypeDescriptor * pEnclosingElementType) const; 08577 08578 08579 static CElement * 08580 s_construct (void); 08581 08582 static void 08583 s_decodeFields ( 08584 CDecoderStream * pDecoderStream, 08585 CElement * pElement); 08587 08588 08589 protected: 08590 llrp_u1_t m_EnableAntDwellTimeLimit; 08591 08594 public: 08595 static const CFieldDescriptor 08596 s_fdEnableAntDwellTimeLimit; 08598 08600 inline llrp_u1_t 08601 getEnableAntDwellTimeLimit (void) 08602 { 08603 return m_EnableAntDwellTimeLimit; 08604 } 08605 08607 inline void 08608 setEnableAntDwellTimeLimit ( 08609 llrp_u1_t value) 08610 { 08611 m_EnableAntDwellTimeLimit = value; 08612 } 08613 08614 08615 protected: 08616 llrp_u1_t m_EnableSelectGapClose; 08617 08620 public: 08621 static const CFieldDescriptor 08622 s_fdEnableSelectGapClose; 08624 08626 inline llrp_u1_t 08627 getEnableSelectGapClose (void) 08628 { 08629 return m_EnableSelectGapClose; 08630 } 08631 08633 inline void 08634 setEnableSelectGapClose ( 08635 llrp_u1_t value) 08636 { 08637 m_EnableSelectGapClose = value; 08638 } 08639 08640 08641 08642 protected: 08643 std::list<CParameter *> m_listCustom; 08644 08645 public: 08647 inline std::list<CParameter *>::iterator 08648 beginCustom (void) 08649 { 08650 return m_listCustom.begin(); 08651 } 08652 08654 inline std::list<CParameter *>::iterator 08655 endCustom (void) 08656 { 08657 return m_listCustom.end(); 08658 } 08659 08661 inline void 08662 clearCustom (void) 08663 { 08664 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08665 } 08666 08668 inline int 08669 countCustom (void) 08670 { 08671 return (int) (m_listCustom.size()); 08672 } 08673 08674 EResultCode 08676 addCustom ( 08677 CParameter * pValue); 08678 08679 08680 }; 08681 08682 08709 class CImpinjArrayVersion : public CParameter 08710 { 08711 public: 08712 CImpinjArrayVersion (void); 08713 ~CImpinjArrayVersion (void); 08714 08717 08718 static const CFieldDescriptor * const 08719 s_apFieldDescriptorTable[]; 08720 08721 static const CTypeDescriptor 08722 s_typeDescriptor; 08723 08724 void 08725 decodeFields ( 08726 CDecoderStream * pDecoderStream); 08727 08728 void 08729 assimilateSubParameters ( 08730 CErrorDetails * pError); 08731 08732 void 08733 encode ( 08734 CEncoderStream * pEncoderStream) const; 08735 08736 08737 llrp_bool_t 08738 isAllowedIn ( 08739 const CTypeDescriptor * pEnclosingElementType) const; 08740 08741 08742 static CElement * 08743 s_construct (void); 08744 08745 static void 08746 s_decodeFields ( 08747 CDecoderStream * pDecoderStream, 08748 CElement * pElement); 08750 08751 08752 protected: 08753 llrp_utf8v_t m_SerialNumber; 08754 08757 public: 08758 static const CFieldDescriptor 08759 s_fdSerialNumber; 08761 08763 inline llrp_utf8v_t 08764 getSerialNumber (void) 08765 { 08766 return m_SerialNumber; 08767 } 08768 08770 inline void 08771 setSerialNumber ( 08772 llrp_utf8v_t value) 08773 { 08774 m_SerialNumber = value; 08775 } 08776 08777 08778 protected: 08779 llrp_utf8v_t m_FirmwareVersion; 08780 08783 public: 08784 static const CFieldDescriptor 08785 s_fdFirmwareVersion; 08787 08789 inline llrp_utf8v_t 08790 getFirmwareVersion (void) 08791 { 08792 return m_FirmwareVersion; 08793 } 08794 08796 inline void 08797 setFirmwareVersion ( 08798 llrp_utf8v_t value) 08799 { 08800 m_FirmwareVersion = value; 08801 } 08802 08803 08804 protected: 08805 llrp_utf8v_t m_PCBAVersion; 08806 08809 public: 08810 static const CFieldDescriptor 08811 s_fdPCBAVersion; 08813 08815 inline llrp_utf8v_t 08816 getPCBAVersion (void) 08817 { 08818 return m_PCBAVersion; 08819 } 08820 08822 inline void 08823 setPCBAVersion ( 08824 llrp_utf8v_t value) 08825 { 08826 m_PCBAVersion = value; 08827 } 08828 08829 08830 08831 protected: 08832 std::list<CParameter *> m_listCustom; 08833 08834 public: 08836 inline std::list<CParameter *>::iterator 08837 beginCustom (void) 08838 { 08839 return m_listCustom.begin(); 08840 } 08841 08843 inline std::list<CParameter *>::iterator 08844 endCustom (void) 08845 { 08846 return m_listCustom.end(); 08847 } 08848 08850 inline void 08851 clearCustom (void) 08852 { 08853 clearSubParameterList ((tListOfParameters *) &m_listCustom); 08854 } 08855 08857 inline int 08858 countCustom (void) 08859 { 08860 return (int) (m_listCustom.size()); 08861 } 08862 08863 EResultCode 08865 addCustom ( 08866 CParameter * pValue); 08867 08868 08869 }; 08870 08871 08904 class CImpinjxArrayCapabilities : public CParameter 08905 { 08906 public: 08907 CImpinjxArrayCapabilities (void); 08908 ~CImpinjxArrayCapabilities (void); 08909 08912 08913 static const CFieldDescriptor * const 08914 s_apFieldDescriptorTable[]; 08915 08916 static const CTypeDescriptor 08917 s_typeDescriptor; 08918 08919 void 08920 decodeFields ( 08921 CDecoderStream * pDecoderStream); 08922 08923 void 08924 assimilateSubParameters ( 08925 CErrorDetails * pError); 08926 08927 void 08928 encode ( 08929 CEncoderStream * pEncoderStream) const; 08930 08931 08932 llrp_bool_t 08933 isAllowedIn ( 08934 const CTypeDescriptor * pEnclosingElementType) const; 08935 08936 08937 static CElement * 08938 s_construct (void); 08939 08940 static void 08941 s_decodeFields ( 08942 CDecoderStream * pDecoderStream, 08943 CElement * pElement); 08945 08946 08947 protected: 08948 llrp_u32_t m_MaxNumSectors; 08949 08952 public: 08953 static const CFieldDescriptor 08954 s_fdMaxNumSectors; 08956 08958 inline llrp_u32_t 08959 getMaxNumSectors (void) 08960 { 08961 return m_MaxNumSectors; 08962 } 08963 08965 inline void 08966 setMaxNumSectors ( 08967 llrp_u32_t value) 08968 { 08969 m_MaxNumSectors = value; 08970 } 08971 08972 08973 protected: 08974 llrp_u1_t m_SupportsLISpecs; 08975 08978 public: 08979 static const CFieldDescriptor 08980 s_fdSupportsLISpecs; 08982 08984 inline llrp_u1_t 08985 getSupportsLISpecs (void) 08986 { 08987 return m_SupportsLISpecs; 08988 } 08989 08991 inline void 08992 setSupportsLISpecs ( 08993 llrp_u1_t value) 08994 { 08995 m_SupportsLISpecs = value; 08996 } 08997 08998 08999 protected: 09000 llrp_u1_t m_SupportsTISpecs; 09001 09004 public: 09005 static const CFieldDescriptor 09006 s_fdSupportsTISpecs; 09008 09010 inline llrp_u1_t 09011 getSupportsTISpecs (void) 09012 { 09013 return m_SupportsTISpecs; 09014 } 09015 09017 inline void 09018 setSupportsTISpecs ( 09019 llrp_u1_t value) 09020 { 09021 m_SupportsTISpecs = value; 09022 } 09023 09024 09025 protected: 09026 llrp_u1_t m_SupportsTSISpecs; 09027 09030 public: 09031 static const CFieldDescriptor 09032 s_fdSupportsTSISpecs; 09034 09036 inline llrp_u1_t 09037 getSupportsTSISpecs (void) 09038 { 09039 return m_SupportsTSISpecs; 09040 } 09041 09043 inline void 09044 setSupportsTSISpecs ( 09045 llrp_u1_t value) 09046 { 09047 m_SupportsTSISpecs = value; 09048 } 09049 09050 09051 protected: 09052 llrp_u1_t m_SupportsDISpecs; 09053 09056 public: 09057 static const CFieldDescriptor 09058 s_fdSupportsDISpecs; 09060 09062 inline llrp_u1_t 09063 getSupportsDISpecs (void) 09064 { 09065 return m_SupportsDISpecs; 09066 } 09067 09069 inline void 09070 setSupportsDISpecs ( 09071 llrp_u1_t value) 09072 { 09073 m_SupportsDISpecs = value; 09074 } 09075 09076 09077 09078 protected: 09079 CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities; 09080 09081 public: 09083 inline CImpinjxArrayDirectionCapabilities * 09084 getImpinjxArrayDirectionCapabilities (void) 09085 { 09086 return m_pImpinjxArrayDirectionCapabilities; 09087 } 09088 09090 EResultCode 09091 setImpinjxArrayDirectionCapabilities ( 09092 CImpinjxArrayDirectionCapabilities * pValue); 09093 09094 09095 protected: 09096 std::list<CParameter *> m_listCustom; 09097 09098 public: 09100 inline std::list<CParameter *>::iterator 09101 beginCustom (void) 09102 { 09103 return m_listCustom.begin(); 09104 } 09105 09107 inline std::list<CParameter *>::iterator 09108 endCustom (void) 09109 { 09110 return m_listCustom.end(); 09111 } 09112 09114 inline void 09115 clearCustom (void) 09116 { 09117 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09118 } 09119 09121 inline int 09122 countCustom (void) 09123 { 09124 return (int) (m_listCustom.size()); 09125 } 09126 09127 EResultCode 09129 addCustom ( 09130 CParameter * pValue); 09131 09132 09133 }; 09134 09135 09163 class CImpinjTiltConfiguration : public CParameter 09164 { 09165 public: 09166 CImpinjTiltConfiguration (void); 09167 ~CImpinjTiltConfiguration (void); 09168 09171 09172 static const CFieldDescriptor * const 09173 s_apFieldDescriptorTable[]; 09174 09175 static const CTypeDescriptor 09176 s_typeDescriptor; 09177 09178 void 09179 decodeFields ( 09180 CDecoderStream * pDecoderStream); 09181 09182 void 09183 assimilateSubParameters ( 09184 CErrorDetails * pError); 09185 09186 void 09187 encode ( 09188 CEncoderStream * pEncoderStream) const; 09189 09190 09191 llrp_bool_t 09192 isAllowedIn ( 09193 const CTypeDescriptor * pEnclosingElementType) const; 09194 09195 09196 static CElement * 09197 s_construct (void); 09198 09199 static void 09200 s_decodeFields ( 09201 CDecoderStream * pDecoderStream, 09202 CElement * pElement); 09204 09205 09206 protected: 09207 llrp_s32_t m_XAxis; 09208 09211 public: 09212 static const CFieldDescriptor 09213 s_fdXAxis; 09215 09217 inline llrp_s32_t 09218 getXAxis (void) 09219 { 09220 return m_XAxis; 09221 } 09222 09224 inline void 09225 setXAxis ( 09226 llrp_s32_t value) 09227 { 09228 m_XAxis = value; 09229 } 09230 09231 09232 protected: 09233 llrp_s32_t m_YAxis; 09234 09237 public: 09238 static const CFieldDescriptor 09239 s_fdYAxis; 09241 09243 inline llrp_s32_t 09244 getYAxis (void) 09245 { 09246 return m_YAxis; 09247 } 09248 09250 inline void 09251 setYAxis ( 09252 llrp_s32_t value) 09253 { 09254 m_YAxis = value; 09255 } 09256 09257 09258 protected: 09259 llrp_s32_t m_ZAxis; 09260 09263 public: 09264 static const CFieldDescriptor 09265 s_fdZAxis; 09267 09269 inline llrp_s32_t 09270 getZAxis (void) 09271 { 09272 return m_ZAxis; 09273 } 09274 09276 inline void 09277 setZAxis ( 09278 llrp_s32_t value) 09279 { 09280 m_ZAxis = value; 09281 } 09282 09283 09284 09285 protected: 09286 std::list<CParameter *> m_listCustom; 09287 09288 public: 09290 inline std::list<CParameter *>::iterator 09291 beginCustom (void) 09292 { 09293 return m_listCustom.begin(); 09294 } 09295 09297 inline std::list<CParameter *>::iterator 09298 endCustom (void) 09299 { 09300 return m_listCustom.end(); 09301 } 09302 09304 inline void 09305 clearCustom (void) 09306 { 09307 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09308 } 09309 09311 inline int 09312 countCustom (void) 09313 { 09314 return (int) (m_listCustom.size()); 09315 } 09316 09317 EResultCode 09319 addCustom ( 09320 CParameter * pValue); 09321 09322 09323 }; 09324 09325 09354 class CImpinjBeaconConfiguration : public CParameter 09355 { 09356 public: 09357 CImpinjBeaconConfiguration (void); 09358 ~CImpinjBeaconConfiguration (void); 09359 09362 09363 static const CFieldDescriptor * const 09364 s_apFieldDescriptorTable[]; 09365 09366 static const CTypeDescriptor 09367 s_typeDescriptor; 09368 09369 void 09370 decodeFields ( 09371 CDecoderStream * pDecoderStream); 09372 09373 void 09374 assimilateSubParameters ( 09375 CErrorDetails * pError); 09376 09377 void 09378 encode ( 09379 CEncoderStream * pEncoderStream) const; 09380 09381 09382 llrp_bool_t 09383 isAllowedIn ( 09384 const CTypeDescriptor * pEnclosingElementType) const; 09385 09386 09387 static CElement * 09388 s_construct (void); 09389 09390 static void 09391 s_decodeFields ( 09392 CDecoderStream * pDecoderStream, 09393 CElement * pElement); 09395 09396 09397 protected: 09398 llrp_u1_t m_BeaconState; 09399 09402 public: 09403 static const CFieldDescriptor 09404 s_fdBeaconState; 09406 09408 inline llrp_u1_t 09409 getBeaconState (void) 09410 { 09411 return m_BeaconState; 09412 } 09413 09415 inline void 09416 setBeaconState ( 09417 llrp_u1_t value) 09418 { 09419 m_BeaconState = value; 09420 } 09421 09422 09423 protected: 09424 llrp_u64_t m_BeaconDurationSeconds; 09425 09428 public: 09429 static const CFieldDescriptor 09430 s_fdBeaconDurationSeconds; 09432 09434 inline llrp_u64_t 09435 getBeaconDurationSeconds (void) 09436 { 09437 return m_BeaconDurationSeconds; 09438 } 09439 09441 inline void 09442 setBeaconDurationSeconds ( 09443 llrp_u64_t value) 09444 { 09445 m_BeaconDurationSeconds = value; 09446 } 09447 09448 09449 09450 protected: 09451 std::list<CParameter *> m_listCustom; 09452 09453 public: 09455 inline std::list<CParameter *>::iterator 09456 beginCustom (void) 09457 { 09458 return m_listCustom.begin(); 09459 } 09460 09462 inline std::list<CParameter *>::iterator 09463 endCustom (void) 09464 { 09465 return m_listCustom.end(); 09466 } 09467 09469 inline void 09470 clearCustom (void) 09471 { 09472 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09473 } 09474 09476 inline int 09477 countCustom (void) 09478 { 09479 return (int) (m_listCustom.size()); 09480 } 09481 09482 EResultCode 09484 addCustom ( 09485 CParameter * pValue); 09486 09487 09488 }; 09489 09490 09518 class CImpinjAntennaConfiguration : public CParameter 09519 { 09520 public: 09521 CImpinjAntennaConfiguration (void); 09522 ~CImpinjAntennaConfiguration (void); 09523 09526 09527 static const CFieldDescriptor * const 09528 s_apFieldDescriptorTable[]; 09529 09530 static const CTypeDescriptor 09531 s_typeDescriptor; 09532 09533 void 09534 decodeFields ( 09535 CDecoderStream * pDecoderStream); 09536 09537 void 09538 assimilateSubParameters ( 09539 CErrorDetails * pError); 09540 09541 void 09542 encode ( 09543 CEncoderStream * pEncoderStream) const; 09544 09545 09546 llrp_bool_t 09547 isAllowedIn ( 09548 const CTypeDescriptor * pEnclosingElementType) const; 09549 09550 09551 static CElement * 09552 s_construct (void); 09553 09554 static void 09555 s_decodeFields ( 09556 CDecoderStream * pDecoderStream, 09557 CElement * pElement); 09559 09560 09561 09562 protected: 09563 CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis; 09564 09565 public: 09567 inline CImpinjAntennaEventHysteresis * 09568 getImpinjAntennaEventHysteresis (void) 09569 { 09570 return m_pImpinjAntennaEventHysteresis; 09571 } 09572 09574 EResultCode 09575 setImpinjAntennaEventHysteresis ( 09576 CImpinjAntennaEventHysteresis * pValue); 09577 09578 09579 protected: 09580 CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration; 09581 09582 public: 09584 inline CImpinjAntennaEventConfiguration * 09585 getImpinjAntennaEventConfiguration (void) 09586 { 09587 return m_pImpinjAntennaEventConfiguration; 09588 } 09589 09591 EResultCode 09592 setImpinjAntennaEventConfiguration ( 09593 CImpinjAntennaEventConfiguration * pValue); 09594 09595 09596 protected: 09597 std::list<CParameter *> m_listCustom; 09598 09599 public: 09601 inline std::list<CParameter *>::iterator 09602 beginCustom (void) 09603 { 09604 return m_listCustom.begin(); 09605 } 09606 09608 inline std::list<CParameter *>::iterator 09609 endCustom (void) 09610 { 09611 return m_listCustom.end(); 09612 } 09613 09615 inline void 09616 clearCustom (void) 09617 { 09618 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09619 } 09620 09622 inline int 09623 countCustom (void) 09624 { 09625 return (int) (m_listCustom.size()); 09626 } 09627 09628 EResultCode 09630 addCustom ( 09631 CParameter * pValue); 09632 09633 09634 }; 09635 09636 09668 class CImpinjAntennaEventHysteresis : public CParameter 09669 { 09670 public: 09671 CImpinjAntennaEventHysteresis (void); 09672 ~CImpinjAntennaEventHysteresis (void); 09673 09676 09677 static const CFieldDescriptor * const 09678 s_apFieldDescriptorTable[]; 09679 09680 static const CTypeDescriptor 09681 s_typeDescriptor; 09682 09683 void 09684 decodeFields ( 09685 CDecoderStream * pDecoderStream); 09686 09687 void 09688 assimilateSubParameters ( 09689 CErrorDetails * pError); 09690 09691 void 09692 encode ( 09693 CEncoderStream * pEncoderStream) const; 09694 09695 09696 llrp_bool_t 09697 isAllowedIn ( 09698 const CTypeDescriptor * pEnclosingElementType) const; 09699 09700 09701 static CElement * 09702 s_construct (void); 09703 09704 static void 09705 s_decodeFields ( 09706 CDecoderStream * pDecoderStream, 09707 CElement * pElement); 09709 09710 09711 protected: 09712 llrp_u64_t m_AntennaEventConnected; 09713 09716 public: 09717 static const CFieldDescriptor 09718 s_fdAntennaEventConnected; 09720 09722 inline llrp_u64_t 09723 getAntennaEventConnected (void) 09724 { 09725 return m_AntennaEventConnected; 09726 } 09727 09729 inline void 09730 setAntennaEventConnected ( 09731 llrp_u64_t value) 09732 { 09733 m_AntennaEventConnected = value; 09734 } 09735 09736 09737 protected: 09738 llrp_u64_t m_AntennaEventDisconnected; 09739 09742 public: 09743 static const CFieldDescriptor 09744 s_fdAntennaEventDisconnected; 09746 09748 inline llrp_u64_t 09749 getAntennaEventDisconnected (void) 09750 { 09751 return m_AntennaEventDisconnected; 09752 } 09753 09755 inline void 09756 setAntennaEventDisconnected ( 09757 llrp_u64_t value) 09758 { 09759 m_AntennaEventDisconnected = value; 09760 } 09761 09762 09763 09764 protected: 09765 std::list<CParameter *> m_listCustom; 09766 09767 public: 09769 inline std::list<CParameter *>::iterator 09770 beginCustom (void) 09771 { 09772 return m_listCustom.begin(); 09773 } 09774 09776 inline std::list<CParameter *>::iterator 09777 endCustom (void) 09778 { 09779 return m_listCustom.end(); 09780 } 09781 09783 inline void 09784 clearCustom (void) 09785 { 09786 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09787 } 09788 09790 inline int 09791 countCustom (void) 09792 { 09793 return (int) (m_listCustom.size()); 09794 } 09795 09796 EResultCode 09798 addCustom ( 09799 CParameter * pValue); 09800 09801 09802 }; 09803 09804 09830 class CImpinjAntennaEventConfiguration : public CParameter 09831 { 09832 public: 09833 CImpinjAntennaEventConfiguration (void); 09834 ~CImpinjAntennaEventConfiguration (void); 09835 09838 09839 static const CFieldDescriptor * const 09840 s_apFieldDescriptorTable[]; 09841 09842 static const CTypeDescriptor 09843 s_typeDescriptor; 09844 09845 void 09846 decodeFields ( 09847 CDecoderStream * pDecoderStream); 09848 09849 void 09850 assimilateSubParameters ( 09851 CErrorDetails * pError); 09852 09853 void 09854 encode ( 09855 CEncoderStream * pEncoderStream) const; 09856 09857 09858 llrp_bool_t 09859 isAllowedIn ( 09860 const CTypeDescriptor * pEnclosingElementType) const; 09861 09862 09863 static CElement * 09864 s_construct (void); 09865 09866 static void 09867 s_decodeFields ( 09868 CDecoderStream * pDecoderStream, 09869 CElement * pElement); 09871 09872 09873 protected: 09874 llrp_u1_t m_EnableAntennaAttemptNotification; 09875 09878 public: 09879 static const CFieldDescriptor 09880 s_fdEnableAntennaAttemptNotification; 09882 09884 inline llrp_u1_t 09885 getEnableAntennaAttemptNotification (void) 09886 { 09887 return m_EnableAntennaAttemptNotification; 09888 } 09889 09891 inline void 09892 setEnableAntennaAttemptNotification ( 09893 llrp_u1_t value) 09894 { 09895 m_EnableAntennaAttemptNotification = value; 09896 } 09897 09898 09899 09900 protected: 09901 std::list<CParameter *> m_listCustom; 09902 09903 public: 09905 inline std::list<CParameter *>::iterator 09906 beginCustom (void) 09907 { 09908 return m_listCustom.begin(); 09909 } 09910 09912 inline std::list<CParameter *>::iterator 09913 endCustom (void) 09914 { 09915 return m_listCustom.end(); 09916 } 09917 09919 inline void 09920 clearCustom (void) 09921 { 09922 clearSubParameterList ((tListOfParameters *) &m_listCustom); 09923 } 09924 09926 inline int 09927 countCustom (void) 09928 { 09929 return (int) (m_listCustom.size()); 09930 } 09931 09932 EResultCode 09934 addCustom ( 09935 CParameter * pValue); 09936 09937 09938 }; 09939 09940 09965 class CImpinjAntennaAttemptEvent : public CParameter 09966 { 09967 public: 09968 CImpinjAntennaAttemptEvent (void); 09969 ~CImpinjAntennaAttemptEvent (void); 09970 09973 09974 static const CFieldDescriptor * const 09975 s_apFieldDescriptorTable[]; 09976 09977 static const CTypeDescriptor 09978 s_typeDescriptor; 09979 09980 void 09981 decodeFields ( 09982 CDecoderStream * pDecoderStream); 09983 09984 void 09985 assimilateSubParameters ( 09986 CErrorDetails * pError); 09987 09988 void 09989 encode ( 09990 CEncoderStream * pEncoderStream) const; 09991 09992 09993 llrp_bool_t 09994 isAllowedIn ( 09995 const CTypeDescriptor * pEnclosingElementType) const; 09996 09997 09998 static CElement * 09999 s_construct (void); 10000 10001 static void 10002 s_decodeFields ( 10003 CDecoderStream * pDecoderStream, 10004 CElement * pElement); 10006 10007 10008 protected: 10009 llrp_u16_t m_AntennaID; 10010 10013 public: 10014 static const CFieldDescriptor 10015 s_fdAntennaID; 10017 10019 inline llrp_u16_t 10020 getAntennaID (void) 10021 { 10022 return m_AntennaID; 10023 } 10024 10026 inline void 10027 setAntennaID ( 10028 llrp_u16_t value) 10029 { 10030 m_AntennaID = value; 10031 } 10032 10033 10034 10035 protected: 10036 std::list<CParameter *> m_listCustom; 10037 10038 public: 10040 inline std::list<CParameter *>::iterator 10041 beginCustom (void) 10042 { 10043 return m_listCustom.begin(); 10044 } 10045 10047 inline std::list<CParameter *>::iterator 10048 endCustom (void) 10049 { 10050 return m_listCustom.end(); 10051 } 10052 10054 inline void 10055 clearCustom (void) 10056 { 10057 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10058 } 10059 10061 inline int 10062 countCustom (void) 10063 { 10064 return (int) (m_listCustom.size()); 10065 } 10066 10067 EResultCode 10069 addCustom ( 10070 CParameter * pValue); 10071 10072 10073 }; 10074 10075 10103 class CImpinjHubConfiguration : public CParameter 10104 { 10105 public: 10106 CImpinjHubConfiguration (void); 10107 ~CImpinjHubConfiguration (void); 10108 10111 10112 static const CFieldDescriptor * const 10113 s_apFieldDescriptorTable[]; 10114 10115 static const CTypeDescriptor 10116 s_typeDescriptor; 10117 10118 void 10119 decodeFields ( 10120 CDecoderStream * pDecoderStream); 10121 10122 void 10123 assimilateSubParameters ( 10124 CErrorDetails * pError); 10125 10126 void 10127 encode ( 10128 CEncoderStream * pEncoderStream) const; 10129 10130 10131 llrp_bool_t 10132 isAllowedIn ( 10133 const CTypeDescriptor * pEnclosingElementType) const; 10134 10135 10136 static CElement * 10137 s_construct (void); 10138 10139 static void 10140 s_decodeFields ( 10141 CDecoderStream * pDecoderStream, 10142 CElement * pElement); 10144 10145 10146 protected: 10147 llrp_u16_t m_HubID; 10148 10151 public: 10152 static const CFieldDescriptor 10153 s_fdHubID; 10155 10157 inline llrp_u16_t 10158 getHubID (void) 10159 { 10160 return m_HubID; 10161 } 10162 10164 inline void 10165 setHubID ( 10166 llrp_u16_t value) 10167 { 10168 m_HubID = value; 10169 } 10170 10171 10172 protected: 10173 EImpinjHubConnectedType m_eConnected; 10174 10177 public: 10178 static const CFieldDescriptor 10179 s_fdConnected; 10181 10183 inline EImpinjHubConnectedType 10184 getConnected (void) 10185 { 10186 return m_eConnected; 10187 } 10188 10190 inline void 10191 setConnected ( 10192 EImpinjHubConnectedType value) 10193 { 10194 m_eConnected = value; 10195 } 10196 10197 10198 protected: 10199 EImpinjHubFaultType m_eFault; 10200 10203 public: 10204 static const CFieldDescriptor 10205 s_fdFault; 10207 10209 inline EImpinjHubFaultType 10210 getFault (void) 10211 { 10212 return m_eFault; 10213 } 10214 10216 inline void 10217 setFault ( 10218 EImpinjHubFaultType value) 10219 { 10220 m_eFault = value; 10221 } 10222 10223 10224 10225 protected: 10226 std::list<CParameter *> m_listCustom; 10227 10228 public: 10230 inline std::list<CParameter *>::iterator 10231 beginCustom (void) 10232 { 10233 return m_listCustom.begin(); 10234 } 10235 10237 inline std::list<CParameter *>::iterator 10238 endCustom (void) 10239 { 10240 return m_listCustom.end(); 10241 } 10242 10244 inline void 10245 clearCustom (void) 10246 { 10247 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10248 } 10249 10251 inline int 10252 countCustom (void) 10253 { 10254 return (int) (m_listCustom.size()); 10255 } 10256 10257 EResultCode 10259 addCustom ( 10260 CParameter * pValue); 10261 10262 10263 }; 10264 10265 10289 class CImpinjDiagnosticReport : public CParameter 10290 { 10291 public: 10292 CImpinjDiagnosticReport (void); 10293 ~CImpinjDiagnosticReport (void); 10294 10297 10298 static const CFieldDescriptor * const 10299 s_apFieldDescriptorTable[]; 10300 10301 static const CTypeDescriptor 10302 s_typeDescriptor; 10303 10304 void 10305 decodeFields ( 10306 CDecoderStream * pDecoderStream); 10307 10308 void 10309 assimilateSubParameters ( 10310 CErrorDetails * pError); 10311 10312 void 10313 encode ( 10314 CEncoderStream * pEncoderStream) const; 10315 10316 10317 llrp_bool_t 10318 isAllowedIn ( 10319 const CTypeDescriptor * pEnclosingElementType) const; 10320 10321 10322 static CElement * 10323 s_construct (void); 10324 10325 static void 10326 s_decodeFields ( 10327 CDecoderStream * pDecoderStream, 10328 CElement * pElement); 10330 10331 10332 protected: 10333 llrp_u32v_t m_Metric; 10334 10337 public: 10338 static const CFieldDescriptor 10339 s_fdMetric; 10341 10343 inline llrp_u32v_t 10344 getMetric (void) 10345 { 10346 return m_Metric; 10347 } 10348 10350 inline void 10351 setMetric ( 10352 llrp_u32v_t value) 10353 { 10354 m_Metric = value; 10355 } 10356 10357 10358 10359 }; 10360 10361 10400 class CImpinjPlacementConfiguration : public CParameter 10401 { 10402 public: 10403 CImpinjPlacementConfiguration (void); 10404 ~CImpinjPlacementConfiguration (void); 10405 10408 10409 static const CFieldDescriptor * const 10410 s_apFieldDescriptorTable[]; 10411 10412 static const CTypeDescriptor 10413 s_typeDescriptor; 10414 10415 void 10416 decodeFields ( 10417 CDecoderStream * pDecoderStream); 10418 10419 void 10420 assimilateSubParameters ( 10421 CErrorDetails * pError); 10422 10423 void 10424 encode ( 10425 CEncoderStream * pEncoderStream) const; 10426 10427 10428 llrp_bool_t 10429 isAllowedIn ( 10430 const CTypeDescriptor * pEnclosingElementType) const; 10431 10432 10433 static CElement * 10434 s_construct (void); 10435 10436 static void 10437 s_decodeFields ( 10438 CDecoderStream * pDecoderStream, 10439 CElement * pElement); 10441 10442 10443 protected: 10444 llrp_u16_t m_HeightCm; 10445 10448 public: 10449 static const CFieldDescriptor 10450 s_fdHeightCm; 10452 10454 inline llrp_u16_t 10455 getHeightCm (void) 10456 { 10457 return m_HeightCm; 10458 } 10459 10461 inline void 10462 setHeightCm ( 10463 llrp_u16_t value) 10464 { 10465 m_HeightCm = value; 10466 } 10467 10468 10469 protected: 10470 llrp_s32_t m_FacilityXLocationCm; 10471 10474 public: 10475 static const CFieldDescriptor 10476 s_fdFacilityXLocationCm; 10478 10480 inline llrp_s32_t 10481 getFacilityXLocationCm (void) 10482 { 10483 return m_FacilityXLocationCm; 10484 } 10485 10487 inline void 10488 setFacilityXLocationCm ( 10489 llrp_s32_t value) 10490 { 10491 m_FacilityXLocationCm = value; 10492 } 10493 10494 10495 protected: 10496 llrp_s32_t m_FacilityYLocationCm; 10497 10500 public: 10501 static const CFieldDescriptor 10502 s_fdFacilityYLocationCm; 10504 10506 inline llrp_s32_t 10507 getFacilityYLocationCm (void) 10508 { 10509 return m_FacilityYLocationCm; 10510 } 10511 10513 inline void 10514 setFacilityYLocationCm ( 10515 llrp_s32_t value) 10516 { 10517 m_FacilityYLocationCm = value; 10518 } 10519 10520 10521 protected: 10522 llrp_s16_t m_OrientationDegrees; 10523 10526 public: 10527 static const CFieldDescriptor 10528 s_fdOrientationDegrees; 10530 10532 inline llrp_s16_t 10533 getOrientationDegrees (void) 10534 { 10535 return m_OrientationDegrees; 10536 } 10537 10539 inline void 10540 setOrientationDegrees ( 10541 llrp_s16_t value) 10542 { 10543 m_OrientationDegrees = value; 10544 } 10545 10546 10547 10548 protected: 10549 std::list<CParameter *> m_listCustom; 10550 10551 public: 10553 inline std::list<CParameter *>::iterator 10554 beginCustom (void) 10555 { 10556 return m_listCustom.begin(); 10557 } 10558 10560 inline std::list<CParameter *>::iterator 10561 endCustom (void) 10562 { 10563 return m_listCustom.end(); 10564 } 10565 10567 inline void 10568 clearCustom (void) 10569 { 10570 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10571 } 10572 10574 inline int 10575 countCustom (void) 10576 { 10577 return (int) (m_listCustom.size()); 10578 } 10579 10580 EResultCode 10582 addCustom ( 10583 CParameter * pValue); 10584 10585 10586 }; 10587 10588 10619 class CImpinjLISpec : public CParameter 10620 { 10621 public: 10622 CImpinjLISpec (void); 10623 ~CImpinjLISpec (void); 10624 10627 10628 static const CFieldDescriptor * const 10629 s_apFieldDescriptorTable[]; 10630 10631 static const CTypeDescriptor 10632 s_typeDescriptor; 10633 10634 void 10635 decodeFields ( 10636 CDecoderStream * pDecoderStream); 10637 10638 void 10639 assimilateSubParameters ( 10640 CErrorDetails * pError); 10641 10642 void 10643 encode ( 10644 CEncoderStream * pEncoderStream) const; 10645 10646 10647 llrp_bool_t 10648 isAllowedIn ( 10649 const CTypeDescriptor * pEnclosingElementType) const; 10650 10651 10652 static CElement * 10653 s_construct (void); 10654 10655 static void 10656 s_decodeFields ( 10657 CDecoderStream * pDecoderStream, 10658 CElement * pElement); 10660 10661 10662 10663 protected: 10664 CImpinjLocationConfig * m_pImpinjLocationConfig; 10665 10666 public: 10668 inline CImpinjLocationConfig * 10669 getImpinjLocationConfig (void) 10670 { 10671 return m_pImpinjLocationConfig; 10672 } 10673 10675 EResultCode 10676 setImpinjLocationConfig ( 10677 CImpinjLocationConfig * pValue); 10678 10679 10680 protected: 10681 CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig; 10682 10683 public: 10685 inline CImpinjC1G2LocationConfig * 10686 getImpinjC1G2LocationConfig (void) 10687 { 10688 return m_pImpinjC1G2LocationConfig; 10689 } 10690 10692 EResultCode 10693 setImpinjC1G2LocationConfig ( 10694 CImpinjC1G2LocationConfig * pValue); 10695 10696 10697 protected: 10698 CImpinjLocationReporting * m_pImpinjLocationReporting; 10699 10700 public: 10702 inline CImpinjLocationReporting * 10703 getImpinjLocationReporting (void) 10704 { 10705 return m_pImpinjLocationReporting; 10706 } 10707 10709 EResultCode 10710 setImpinjLocationReporting ( 10711 CImpinjLocationReporting * pValue); 10712 10713 10714 protected: 10715 std::list<CParameter *> m_listCustom; 10716 10717 public: 10719 inline std::list<CParameter *>::iterator 10720 beginCustom (void) 10721 { 10722 return m_listCustom.begin(); 10723 } 10724 10726 inline std::list<CParameter *>::iterator 10727 endCustom (void) 10728 { 10729 return m_listCustom.end(); 10730 } 10731 10733 inline void 10734 clearCustom (void) 10735 { 10736 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10737 } 10738 10740 inline int 10741 countCustom (void) 10742 { 10743 return (int) (m_listCustom.size()); 10744 } 10745 10746 EResultCode 10748 addCustom ( 10749 CParameter * pValue); 10750 10751 10752 }; 10753 10754 10796 class CImpinjLocationConfig : public CParameter 10797 { 10798 public: 10799 CImpinjLocationConfig (void); 10800 ~CImpinjLocationConfig (void); 10801 10804 10805 static const CFieldDescriptor * const 10806 s_apFieldDescriptorTable[]; 10807 10808 static const CTypeDescriptor 10809 s_typeDescriptor; 10810 10811 void 10812 decodeFields ( 10813 CDecoderStream * pDecoderStream); 10814 10815 void 10816 assimilateSubParameters ( 10817 CErrorDetails * pError); 10818 10819 void 10820 encode ( 10821 CEncoderStream * pEncoderStream) const; 10822 10823 10824 llrp_bool_t 10825 isAllowedIn ( 10826 const CTypeDescriptor * pEnclosingElementType) const; 10827 10828 10829 static CElement * 10830 s_construct (void); 10831 10832 static void 10833 s_decodeFields ( 10834 CDecoderStream * pDecoderStream, 10835 CElement * pElement); 10837 10838 10839 protected: 10840 llrp_u16_t m_ComputeWindowSeconds; 10841 10844 public: 10845 static const CFieldDescriptor 10846 s_fdComputeWindowSeconds; 10848 10850 inline llrp_u16_t 10851 getComputeWindowSeconds (void) 10852 { 10853 return m_ComputeWindowSeconds; 10854 } 10855 10857 inline void 10858 setComputeWindowSeconds ( 10859 llrp_u16_t value) 10860 { 10861 m_ComputeWindowSeconds = value; 10862 } 10863 10864 10865 protected: 10866 llrp_u16_t m_TagAgeIntervalSeconds; 10867 10870 public: 10871 static const CFieldDescriptor 10872 s_fdTagAgeIntervalSeconds; 10874 10876 inline llrp_u16_t 10877 getTagAgeIntervalSeconds (void) 10878 { 10879 return m_TagAgeIntervalSeconds; 10880 } 10881 10883 inline void 10884 setTagAgeIntervalSeconds ( 10885 llrp_u16_t value) 10886 { 10887 m_TagAgeIntervalSeconds = value; 10888 } 10889 10890 10891 protected: 10892 llrp_u16_t m_UpdateIntervalSeconds; 10893 10896 public: 10897 static const CFieldDescriptor 10898 s_fdUpdateIntervalSeconds; 10900 10902 inline llrp_u16_t 10903 getUpdateIntervalSeconds (void) 10904 { 10905 return m_UpdateIntervalSeconds; 10906 } 10907 10909 inline void 10910 setUpdateIntervalSeconds ( 10911 llrp_u16_t value) 10912 { 10913 m_UpdateIntervalSeconds = value; 10914 } 10915 10916 10917 10918 protected: 10919 CImpinjDisabledAntennas * m_pImpinjDisabledAntennas; 10920 10921 public: 10923 inline CImpinjDisabledAntennas * 10924 getImpinjDisabledAntennas (void) 10925 { 10926 return m_pImpinjDisabledAntennas; 10927 } 10928 10930 EResultCode 10931 setImpinjDisabledAntennas ( 10932 CImpinjDisabledAntennas * pValue); 10933 10934 10935 protected: 10936 std::list<CParameter *> m_listCustom; 10937 10938 public: 10940 inline std::list<CParameter *>::iterator 10941 beginCustom (void) 10942 { 10943 return m_listCustom.begin(); 10944 } 10945 10947 inline std::list<CParameter *>::iterator 10948 endCustom (void) 10949 { 10950 return m_listCustom.end(); 10951 } 10952 10954 inline void 10955 clearCustom (void) 10956 { 10957 clearSubParameterList ((tListOfParameters *) &m_listCustom); 10958 } 10959 10961 inline int 10962 countCustom (void) 10963 { 10964 return (int) (m_listCustom.size()); 10965 } 10966 10967 EResultCode 10969 addCustom ( 10970 CParameter * pValue); 10971 10972 10973 }; 10974 10975 11018 class CImpinjC1G2LocationConfig : public CParameter 11019 { 11020 public: 11021 CImpinjC1G2LocationConfig (void); 11022 ~CImpinjC1G2LocationConfig (void); 11023 11026 11027 static const CFieldDescriptor * const 11028 s_apFieldDescriptorTable[]; 11029 11030 static const CTypeDescriptor 11031 s_typeDescriptor; 11032 11033 void 11034 decodeFields ( 11035 CDecoderStream * pDecoderStream); 11036 11037 void 11038 assimilateSubParameters ( 11039 CErrorDetails * pError); 11040 11041 void 11042 encode ( 11043 CEncoderStream * pEncoderStream) const; 11044 11045 11046 llrp_bool_t 11047 isAllowedIn ( 11048 const CTypeDescriptor * pEnclosingElementType) const; 11049 11050 11051 static CElement * 11052 s_construct (void); 11053 11054 static void 11055 s_decodeFields ( 11056 CDecoderStream * pDecoderStream, 11057 CElement * pElement); 11059 11060 11061 protected: 11062 llrp_u16_t m_ModeIndex; 11063 11066 public: 11067 static const CFieldDescriptor 11068 s_fdModeIndex; 11070 11072 inline llrp_u16_t 11073 getModeIndex (void) 11074 { 11075 return m_ModeIndex; 11076 } 11077 11079 inline void 11080 setModeIndex ( 11081 llrp_u16_t value) 11082 { 11083 m_ModeIndex = value; 11084 } 11085 11086 11087 protected: 11088 llrp_u2_t m_Session; 11089 11092 public: 11093 static const CFieldDescriptor 11094 s_fdSession; 11096 11098 inline llrp_u2_t 11099 getSession (void) 11100 { 11101 return m_Session; 11102 } 11103 11105 inline void 11106 setSession ( 11107 llrp_u2_t value) 11108 { 11109 m_Session = value; 11110 } 11111 11112 11113 11114 protected: 11115 std::list<CC1G2Filter *> m_listC1G2Filter; 11116 11117 public: 11119 inline std::list<CC1G2Filter *>::iterator 11120 beginC1G2Filter (void) 11121 { 11122 return m_listC1G2Filter.begin(); 11123 } 11124 11126 inline std::list<CC1G2Filter *>::iterator 11127 endC1G2Filter (void) 11128 { 11129 return m_listC1G2Filter.end(); 11130 } 11131 11133 inline void 11134 clearC1G2Filter (void) 11135 { 11136 clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter); 11137 } 11138 11140 inline int 11141 countC1G2Filter (void) 11142 { 11143 return (int) (m_listC1G2Filter.size()); 11144 } 11145 11146 EResultCode 11148 addC1G2Filter ( 11149 CC1G2Filter * pValue); 11150 11151 11152 protected: 11153 CImpinjTransmitPower * m_pImpinjTransmitPower; 11154 11155 public: 11157 inline CImpinjTransmitPower * 11158 getImpinjTransmitPower (void) 11159 { 11160 return m_pImpinjTransmitPower; 11161 } 11162 11164 EResultCode 11165 setImpinjTransmitPower ( 11166 CImpinjTransmitPower * pValue); 11167 11168 11169 protected: 11170 std::list<CParameter *> m_listCustom; 11171 11172 public: 11174 inline std::list<CParameter *>::iterator 11175 beginCustom (void) 11176 { 11177 return m_listCustom.begin(); 11178 } 11179 11181 inline std::list<CParameter *>::iterator 11182 endCustom (void) 11183 { 11184 return m_listCustom.end(); 11185 } 11186 11188 inline void 11189 clearCustom (void) 11190 { 11191 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11192 } 11193 11195 inline int 11196 countCustom (void) 11197 { 11198 return (int) (m_listCustom.size()); 11199 } 11200 11201 EResultCode 11203 addCustom ( 11204 CParameter * pValue); 11205 11206 11207 }; 11208 11209 11251 class CImpinjLocationReporting : public CParameter 11252 { 11253 public: 11254 CImpinjLocationReporting (void); 11255 ~CImpinjLocationReporting (void); 11256 11259 11260 static const CFieldDescriptor * const 11261 s_apFieldDescriptorTable[]; 11262 11263 static const CTypeDescriptor 11264 s_typeDescriptor; 11265 11266 void 11267 decodeFields ( 11268 CDecoderStream * pDecoderStream); 11269 11270 void 11271 assimilateSubParameters ( 11272 CErrorDetails * pError); 11273 11274 void 11275 encode ( 11276 CEncoderStream * pEncoderStream) const; 11277 11278 11279 llrp_bool_t 11280 isAllowedIn ( 11281 const CTypeDescriptor * pEnclosingElementType) const; 11282 11283 11284 static CElement * 11285 s_construct (void); 11286 11287 static void 11288 s_decodeFields ( 11289 CDecoderStream * pDecoderStream, 11290 CElement * pElement); 11292 11293 11294 protected: 11295 llrp_u1_t m_EnableUpdateReport; 11296 11299 public: 11300 static const CFieldDescriptor 11301 s_fdEnableUpdateReport; 11303 11305 inline llrp_u1_t 11306 getEnableUpdateReport (void) 11307 { 11308 return m_EnableUpdateReport; 11309 } 11310 11312 inline void 11313 setEnableUpdateReport ( 11314 llrp_u1_t value) 11315 { 11316 m_EnableUpdateReport = value; 11317 } 11318 11319 11320 protected: 11321 llrp_u1_t m_EnableEntryReport; 11322 11325 public: 11326 static const CFieldDescriptor 11327 s_fdEnableEntryReport; 11329 11331 inline llrp_u1_t 11332 getEnableEntryReport (void) 11333 { 11334 return m_EnableEntryReport; 11335 } 11336 11338 inline void 11339 setEnableEntryReport ( 11340 llrp_u1_t value) 11341 { 11342 m_EnableEntryReport = value; 11343 } 11344 11345 11346 protected: 11347 llrp_u1_t m_EnableExitReport; 11348 11351 public: 11352 static const CFieldDescriptor 11353 s_fdEnableExitReport; 11355 11357 inline llrp_u1_t 11358 getEnableExitReport (void) 11359 { 11360 return m_EnableExitReport; 11361 } 11362 11364 inline void 11365 setEnableExitReport ( 11366 llrp_u1_t value) 11367 { 11368 m_EnableExitReport = value; 11369 } 11370 11371 11372 protected: 11373 llrp_u1_t m_EnableDiagnosticReport; 11374 11377 public: 11378 static const CFieldDescriptor 11379 s_fdEnableDiagnosticReport; 11381 11383 inline llrp_u1_t 11384 getEnableDiagnosticReport (void) 11385 { 11386 return m_EnableDiagnosticReport; 11387 } 11388 11390 inline void 11391 setEnableDiagnosticReport ( 11392 llrp_u1_t value) 11393 { 11394 m_EnableDiagnosticReport = value; 11395 } 11396 11397 11398 11399 protected: 11400 std::list<CParameter *> m_listCustom; 11401 11402 public: 11404 inline std::list<CParameter *>::iterator 11405 beginCustom (void) 11406 { 11407 return m_listCustom.begin(); 11408 } 11409 11411 inline std::list<CParameter *>::iterator 11412 endCustom (void) 11413 { 11414 return m_listCustom.end(); 11415 } 11416 11418 inline void 11419 clearCustom (void) 11420 { 11421 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11422 } 11423 11425 inline int 11426 countCustom (void) 11427 { 11428 return (int) (m_listCustom.size()); 11429 } 11430 11431 EResultCode 11433 addCustom ( 11434 CParameter * pValue); 11435 11436 11437 }; 11438 11439 11470 class CImpinjLocationConfidence : public CParameter 11471 { 11472 public: 11473 CImpinjLocationConfidence (void); 11474 ~CImpinjLocationConfidence (void); 11475 11478 11479 static const CFieldDescriptor * const 11480 s_apFieldDescriptorTable[]; 11481 11482 static const CTypeDescriptor 11483 s_typeDescriptor; 11484 11485 void 11486 decodeFields ( 11487 CDecoderStream * pDecoderStream); 11488 11489 void 11490 assimilateSubParameters ( 11491 CErrorDetails * pError); 11492 11493 void 11494 encode ( 11495 CEncoderStream * pEncoderStream) const; 11496 11497 11498 llrp_bool_t 11499 isAllowedIn ( 11500 const CTypeDescriptor * pEnclosingElementType) const; 11501 11502 11503 static CElement * 11504 s_construct (void); 11505 11506 static void 11507 s_decodeFields ( 11508 CDecoderStream * pDecoderStream, 11509 CElement * pElement); 11511 11512 11513 protected: 11514 llrp_u16_t m_ReadCount; 11515 11518 public: 11519 static const CFieldDescriptor 11520 s_fdReadCount; 11522 11524 inline llrp_u16_t 11525 getReadCount (void) 11526 { 11527 return m_ReadCount; 11528 } 11529 11531 inline void 11532 setReadCount ( 11533 llrp_u16_t value) 11534 { 11535 m_ReadCount = value; 11536 } 11537 11538 11539 protected: 11540 llrp_u32v_t m_ConfidenceData; 11541 11544 public: 11545 static const CFieldDescriptor 11546 s_fdConfidenceData; 11548 11550 inline llrp_u32v_t 11551 getConfidenceData (void) 11552 { 11553 return m_ConfidenceData; 11554 } 11555 11557 inline void 11558 setConfidenceData ( 11559 llrp_u32v_t value) 11560 { 11561 m_ConfidenceData = value; 11562 } 11563 11564 11565 11566 protected: 11567 std::list<CParameter *> m_listCustom; 11568 11569 public: 11571 inline std::list<CParameter *>::iterator 11572 beginCustom (void) 11573 { 11574 return m_listCustom.begin(); 11575 } 11576 11578 inline std::list<CParameter *>::iterator 11579 endCustom (void) 11580 { 11581 return m_listCustom.end(); 11582 } 11583 11585 inline void 11586 clearCustom (void) 11587 { 11588 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11589 } 11590 11592 inline int 11593 countCustom (void) 11594 { 11595 return (int) (m_listCustom.size()); 11596 } 11597 11598 EResultCode 11600 addCustom ( 11601 CParameter * pValue); 11602 11603 11604 }; 11605 11606 11644 class CImpinjLocationReportData : public CParameter 11645 { 11646 public: 11647 CImpinjLocationReportData (void); 11648 ~CImpinjLocationReportData (void); 11649 11652 11653 static const CFieldDescriptor * const 11654 s_apFieldDescriptorTable[]; 11655 11656 static const CTypeDescriptor 11657 s_typeDescriptor; 11658 11659 void 11660 decodeFields ( 11661 CDecoderStream * pDecoderStream); 11662 11663 void 11664 assimilateSubParameters ( 11665 CErrorDetails * pError); 11666 11667 void 11668 encode ( 11669 CEncoderStream * pEncoderStream) const; 11670 11671 11672 llrp_bool_t 11673 isAllowedIn ( 11674 const CTypeDescriptor * pEnclosingElementType) const; 11675 11676 11677 static CElement * 11678 s_construct (void); 11679 11680 static void 11681 s_decodeFields ( 11682 CDecoderStream * pDecoderStream, 11683 CElement * pElement); 11685 11686 11687 protected: 11688 llrp_u64_t m_LastSeenTimestampUTC; 11689 11692 public: 11693 static const CFieldDescriptor 11694 s_fdLastSeenTimestampUTC; 11696 11698 inline llrp_u64_t 11699 getLastSeenTimestampUTC (void) 11700 { 11701 return m_LastSeenTimestampUTC; 11702 } 11703 11705 inline void 11706 setLastSeenTimestampUTC ( 11707 llrp_u64_t value) 11708 { 11709 m_LastSeenTimestampUTC = value; 11710 } 11711 11712 11713 protected: 11714 llrp_s32_t m_LocXCentimeters; 11715 11718 public: 11719 static const CFieldDescriptor 11720 s_fdLocXCentimeters; 11722 11724 inline llrp_s32_t 11725 getLocXCentimeters (void) 11726 { 11727 return m_LocXCentimeters; 11728 } 11729 11731 inline void 11732 setLocXCentimeters ( 11733 llrp_s32_t value) 11734 { 11735 m_LocXCentimeters = value; 11736 } 11737 11738 11739 protected: 11740 llrp_s32_t m_LocYCentimeters; 11741 11744 public: 11745 static const CFieldDescriptor 11746 s_fdLocYCentimeters; 11748 11750 inline llrp_s32_t 11751 getLocYCentimeters (void) 11752 { 11753 return m_LocYCentimeters; 11754 } 11755 11757 inline void 11758 setLocYCentimeters ( 11759 llrp_s32_t value) 11760 { 11761 m_LocYCentimeters = value; 11762 } 11763 11764 11765 protected: 11766 EImpinjLocationReportType m_eType; 11767 11770 public: 11771 static const CFieldDescriptor 11772 s_fdType; 11774 11776 inline EImpinjLocationReportType 11777 getType (void) 11778 { 11779 return m_eType; 11780 } 11781 11783 inline void 11784 setType ( 11785 EImpinjLocationReportType value) 11786 { 11787 m_eType = value; 11788 } 11789 11790 11791 11792 protected: 11793 CImpinjLocationConfidence * m_pImpinjLocationConfidence; 11794 11795 public: 11797 inline CImpinjLocationConfidence * 11798 getImpinjLocationConfidence (void) 11799 { 11800 return m_pImpinjLocationConfidence; 11801 } 11802 11804 EResultCode 11805 setImpinjLocationConfidence ( 11806 CImpinjLocationConfidence * pValue); 11807 11808 11809 protected: 11810 std::list<CParameter *> m_listCustom; 11811 11812 public: 11814 inline std::list<CParameter *>::iterator 11815 beginCustom (void) 11816 { 11817 return m_listCustom.begin(); 11818 } 11819 11821 inline std::list<CParameter *>::iterator 11822 endCustom (void) 11823 { 11824 return m_listCustom.end(); 11825 } 11826 11828 inline void 11829 clearCustom (void) 11830 { 11831 clearSubParameterList ((tListOfParameters *) &m_listCustom); 11832 } 11833 11835 inline int 11836 countCustom (void) 11837 { 11838 return (int) (m_listCustom.size()); 11839 } 11840 11841 EResultCode 11843 addCustom ( 11844 CParameter * pValue); 11845 11846 11847 }; 11848 11849 11882 class CImpinjDISpec : public CParameter 11883 { 11884 public: 11885 CImpinjDISpec (void); 11886 ~CImpinjDISpec (void); 11887 11890 11891 static const CFieldDescriptor * const 11892 s_apFieldDescriptorTable[]; 11893 11894 static const CTypeDescriptor 11895 s_typeDescriptor; 11896 11897 void 11898 decodeFields ( 11899 CDecoderStream * pDecoderStream); 11900 11901 void 11902 assimilateSubParameters ( 11903 CErrorDetails * pError); 11904 11905 void 11906 encode ( 11907 CEncoderStream * pEncoderStream) const; 11908 11909 11910 llrp_bool_t 11911 isAllowedIn ( 11912 const CTypeDescriptor * pEnclosingElementType) const; 11913 11914 11915 static CElement * 11916 s_construct (void); 11917 11918 static void 11919 s_decodeFields ( 11920 CDecoderStream * pDecoderStream, 11921 CElement * pElement); 11923 11924 11925 11926 protected: 11927 CImpinjDirectionSectors * m_pImpinjDirectionSectors; 11928 11929 public: 11931 inline CImpinjDirectionSectors * 11932 getImpinjDirectionSectors (void) 11933 { 11934 return m_pImpinjDirectionSectors; 11935 } 11936 11938 EResultCode 11939 setImpinjDirectionSectors ( 11940 CImpinjDirectionSectors * pValue); 11941 11942 11943 protected: 11944 CImpinjDirectionConfig * m_pImpinjDirectionConfig; 11945 11946 public: 11948 inline CImpinjDirectionConfig * 11949 getImpinjDirectionConfig (void) 11950 { 11951 return m_pImpinjDirectionConfig; 11952 } 11953 11955 EResultCode 11956 setImpinjDirectionConfig ( 11957 CImpinjDirectionConfig * pValue); 11958 11959 11960 protected: 11961 CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig; 11962 11963 public: 11965 inline CImpinjC1G2DirectionConfig * 11966 getImpinjC1G2DirectionConfig (void) 11967 { 11968 return m_pImpinjC1G2DirectionConfig; 11969 } 11970 11972 EResultCode 11973 setImpinjC1G2DirectionConfig ( 11974 CImpinjC1G2DirectionConfig * pValue); 11975 11976 11977 protected: 11978 CImpinjDirectionReporting * m_pImpinjDirectionReporting; 11979 11980 public: 11982 inline CImpinjDirectionReporting * 11983 getImpinjDirectionReporting (void) 11984 { 11985 return m_pImpinjDirectionReporting; 11986 } 11987 11989 EResultCode 11990 setImpinjDirectionReporting ( 11991 CImpinjDirectionReporting * pValue); 11992 11993 11994 protected: 11995 std::list<CParameter *> m_listCustom; 11996 11997 public: 11999 inline std::list<CParameter *>::iterator 12000 beginCustom (void) 12001 { 12002 return m_listCustom.begin(); 12003 } 12004 12006 inline std::list<CParameter *>::iterator 12007 endCustom (void) 12008 { 12009 return m_listCustom.end(); 12010 } 12011 12013 inline void 12014 clearCustom (void) 12015 { 12016 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12017 } 12018 12020 inline int 12021 countCustom (void) 12022 { 12023 return (int) (m_listCustom.size()); 12024 } 12025 12026 EResultCode 12028 addCustom ( 12029 CParameter * pValue); 12030 12031 12032 }; 12033 12034 12062 class CImpinjDirectionSectors : public CParameter 12063 { 12064 public: 12065 CImpinjDirectionSectors (void); 12066 ~CImpinjDirectionSectors (void); 12067 12070 12071 static const CFieldDescriptor * const 12072 s_apFieldDescriptorTable[]; 12073 12074 static const CTypeDescriptor 12075 s_typeDescriptor; 12076 12077 void 12078 decodeFields ( 12079 CDecoderStream * pDecoderStream); 12080 12081 void 12082 assimilateSubParameters ( 12083 CErrorDetails * pError); 12084 12085 void 12086 encode ( 12087 CEncoderStream * pEncoderStream) const; 12088 12089 12090 llrp_bool_t 12091 isAllowedIn ( 12092 const CTypeDescriptor * pEnclosingElementType) const; 12093 12094 12095 static CElement * 12096 s_construct (void); 12097 12098 static void 12099 s_decodeFields ( 12100 CDecoderStream * pDecoderStream, 12101 CElement * pElement); 12103 12104 12105 protected: 12106 llrp_u16v_t m_EnabledSectorIDs; 12107 12110 public: 12111 static const CFieldDescriptor 12112 s_fdEnabledSectorIDs; 12114 12116 inline llrp_u16v_t 12117 getEnabledSectorIDs (void) 12118 { 12119 return m_EnabledSectorIDs; 12120 } 12121 12123 inline void 12124 setEnabledSectorIDs ( 12125 llrp_u16v_t value) 12126 { 12127 m_EnabledSectorIDs = value; 12128 } 12129 12130 12131 12132 protected: 12133 std::list<CParameter *> m_listCustom; 12134 12135 public: 12137 inline std::list<CParameter *>::iterator 12138 beginCustom (void) 12139 { 12140 return m_listCustom.begin(); 12141 } 12142 12144 inline std::list<CParameter *>::iterator 12145 endCustom (void) 12146 { 12147 return m_listCustom.end(); 12148 } 12149 12151 inline void 12152 clearCustom (void) 12153 { 12154 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12155 } 12156 12158 inline int 12159 countCustom (void) 12160 { 12161 return (int) (m_listCustom.size()); 12162 } 12163 12164 EResultCode 12166 addCustom ( 12167 CParameter * pValue); 12168 12169 12170 }; 12171 12172 12211 class CImpinjDirectionConfig : public CParameter 12212 { 12213 public: 12214 CImpinjDirectionConfig (void); 12215 ~CImpinjDirectionConfig (void); 12216 12219 12220 static const CFieldDescriptor * const 12221 s_apFieldDescriptorTable[]; 12222 12223 static const CTypeDescriptor 12224 s_typeDescriptor; 12225 12226 void 12227 decodeFields ( 12228 CDecoderStream * pDecoderStream); 12229 12230 void 12231 assimilateSubParameters ( 12232 CErrorDetails * pError); 12233 12234 void 12235 encode ( 12236 CEncoderStream * pEncoderStream) const; 12237 12238 12239 llrp_bool_t 12240 isAllowedIn ( 12241 const CTypeDescriptor * pEnclosingElementType) const; 12242 12243 12244 static CElement * 12245 s_construct (void); 12246 12247 static void 12248 s_decodeFields ( 12249 CDecoderStream * pDecoderStream, 12250 CElement * pElement); 12252 12253 12254 protected: 12255 llrp_u16_t m_TagAgeIntervalSeconds; 12256 12259 public: 12260 static const CFieldDescriptor 12261 s_fdTagAgeIntervalSeconds; 12263 12265 inline llrp_u16_t 12266 getTagAgeIntervalSeconds (void) 12267 { 12268 return m_TagAgeIntervalSeconds; 12269 } 12270 12272 inline void 12273 setTagAgeIntervalSeconds ( 12274 llrp_u16_t value) 12275 { 12276 m_TagAgeIntervalSeconds = value; 12277 } 12278 12279 12280 protected: 12281 llrp_u16_t m_UpdateIntervalSeconds; 12282 12285 public: 12286 static const CFieldDescriptor 12287 s_fdUpdateIntervalSeconds; 12289 12291 inline llrp_u16_t 12292 getUpdateIntervalSeconds (void) 12293 { 12294 return m_UpdateIntervalSeconds; 12295 } 12296 12298 inline void 12299 setUpdateIntervalSeconds ( 12300 llrp_u16_t value) 12301 { 12302 m_UpdateIntervalSeconds = value; 12303 } 12304 12305 12306 protected: 12307 EImpinjDirectionFieldOfView m_eFieldOfView; 12308 12311 public: 12312 static const CFieldDescriptor 12313 s_fdFieldOfView; 12315 12317 inline EImpinjDirectionFieldOfView 12318 getFieldOfView (void) 12319 { 12320 return m_eFieldOfView; 12321 } 12322 12324 inline void 12325 setFieldOfView ( 12326 EImpinjDirectionFieldOfView value) 12327 { 12328 m_eFieldOfView = value; 12329 } 12330 12331 12332 12333 protected: 12334 CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit; 12335 12336 public: 12338 inline CImpinjDirectionUserTagPopulationLimit * 12339 getImpinjDirectionUserTagPopulationLimit (void) 12340 { 12341 return m_pImpinjDirectionUserTagPopulationLimit; 12342 } 12343 12345 EResultCode 12346 setImpinjDirectionUserTagPopulationLimit ( 12347 CImpinjDirectionUserTagPopulationLimit * pValue); 12348 12349 12350 protected: 12351 std::list<CParameter *> m_listCustom; 12352 12353 public: 12355 inline std::list<CParameter *>::iterator 12356 beginCustom (void) 12357 { 12358 return m_listCustom.begin(); 12359 } 12360 12362 inline std::list<CParameter *>::iterator 12363 endCustom (void) 12364 { 12365 return m_listCustom.end(); 12366 } 12367 12369 inline void 12370 clearCustom (void) 12371 { 12372 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12373 } 12374 12376 inline int 12377 countCustom (void) 12378 { 12379 return (int) (m_listCustom.size()); 12380 } 12381 12382 EResultCode 12384 addCustom ( 12385 CParameter * pValue); 12386 12387 12388 }; 12389 12390 12413 class CImpinjDirectionUserTagPopulationLimit : public CParameter 12414 { 12415 public: 12416 CImpinjDirectionUserTagPopulationLimit (void); 12417 ~CImpinjDirectionUserTagPopulationLimit (void); 12418 12421 12422 static const CFieldDescriptor * const 12423 s_apFieldDescriptorTable[]; 12424 12425 static const CTypeDescriptor 12426 s_typeDescriptor; 12427 12428 void 12429 decodeFields ( 12430 CDecoderStream * pDecoderStream); 12431 12432 void 12433 assimilateSubParameters ( 12434 CErrorDetails * pError); 12435 12436 void 12437 encode ( 12438 CEncoderStream * pEncoderStream) const; 12439 12440 12441 llrp_bool_t 12442 isAllowedIn ( 12443 const CTypeDescriptor * pEnclosingElementType) const; 12444 12445 12446 static CElement * 12447 s_construct (void); 12448 12449 static void 12450 s_decodeFields ( 12451 CDecoderStream * pDecoderStream, 12452 CElement * pElement); 12454 12455 12456 protected: 12457 llrp_u16_t m_UserTagPopulationLimit; 12458 12461 public: 12462 static const CFieldDescriptor 12463 s_fdUserTagPopulationLimit; 12465 12467 inline llrp_u16_t 12468 getUserTagPopulationLimit (void) 12469 { 12470 return m_UserTagPopulationLimit; 12471 } 12472 12474 inline void 12475 setUserTagPopulationLimit ( 12476 llrp_u16_t value) 12477 { 12478 m_UserTagPopulationLimit = value; 12479 } 12480 12481 12482 12483 }; 12484 12485 12523 class CImpinjC1G2DirectionConfig : public CParameter 12524 { 12525 public: 12526 CImpinjC1G2DirectionConfig (void); 12527 ~CImpinjC1G2DirectionConfig (void); 12528 12531 12532 static const CFieldDescriptor * const 12533 s_apFieldDescriptorTable[]; 12534 12535 static const CTypeDescriptor 12536 s_typeDescriptor; 12537 12538 void 12539 decodeFields ( 12540 CDecoderStream * pDecoderStream); 12541 12542 void 12543 assimilateSubParameters ( 12544 CErrorDetails * pError); 12545 12546 void 12547 encode ( 12548 CEncoderStream * pEncoderStream) const; 12549 12550 12551 llrp_bool_t 12552 isAllowedIn ( 12553 const CTypeDescriptor * pEnclosingElementType) const; 12554 12555 12556 static CElement * 12557 s_construct (void); 12558 12559 static void 12560 s_decodeFields ( 12561 CDecoderStream * pDecoderStream, 12562 CElement * pElement); 12564 12565 12566 protected: 12567 EImpinjDirectionRFMode m_eRFMode; 12568 12571 public: 12572 static const CFieldDescriptor 12573 s_fdRFMode; 12575 12577 inline EImpinjDirectionRFMode 12578 getRFMode (void) 12579 { 12580 return m_eRFMode; 12581 } 12582 12584 inline void 12585 setRFMode ( 12586 EImpinjDirectionRFMode value) 12587 { 12588 m_eRFMode = value; 12589 } 12590 12591 12592 12593 protected: 12594 CImpinjTransmitPower * m_pImpinjTransmitPower; 12595 12596 public: 12598 inline CImpinjTransmitPower * 12599 getImpinjTransmitPower (void) 12600 { 12601 return m_pImpinjTransmitPower; 12602 } 12603 12605 EResultCode 12606 setImpinjTransmitPower ( 12607 CImpinjTransmitPower * pValue); 12608 12609 12610 protected: 12611 std::list<CC1G2Filter *> m_listC1G2Filter; 12612 12613 public: 12615 inline std::list<CC1G2Filter *>::iterator 12616 beginC1G2Filter (void) 12617 { 12618 return m_listC1G2Filter.begin(); 12619 } 12620 12622 inline std::list<CC1G2Filter *>::iterator 12623 endC1G2Filter (void) 12624 { 12625 return m_listC1G2Filter.end(); 12626 } 12627 12629 inline void 12630 clearC1G2Filter (void) 12631 { 12632 clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter); 12633 } 12634 12636 inline int 12637 countC1G2Filter (void) 12638 { 12639 return (int) (m_listC1G2Filter.size()); 12640 } 12641 12642 EResultCode 12644 addC1G2Filter ( 12645 CC1G2Filter * pValue); 12646 12647 12648 protected: 12649 std::list<CParameter *> m_listCustom; 12650 12651 public: 12653 inline std::list<CParameter *>::iterator 12654 beginCustom (void) 12655 { 12656 return m_listCustom.begin(); 12657 } 12658 12660 inline std::list<CParameter *>::iterator 12661 endCustom (void) 12662 { 12663 return m_listCustom.end(); 12664 } 12665 12667 inline void 12668 clearCustom (void) 12669 { 12670 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12671 } 12672 12674 inline int 12675 countCustom (void) 12676 { 12677 return (int) (m_listCustom.size()); 12678 } 12679 12680 EResultCode 12682 addCustom ( 12683 CParameter * pValue); 12684 12685 12686 }; 12687 12688 12721 class CImpinjExtendedTagInformation : public CParameter 12722 { 12723 public: 12724 CImpinjExtendedTagInformation (void); 12725 ~CImpinjExtendedTagInformation (void); 12726 12729 12730 static const CFieldDescriptor * const 12731 s_apFieldDescriptorTable[]; 12732 12733 static const CTypeDescriptor 12734 s_typeDescriptor; 12735 12736 void 12737 decodeFields ( 12738 CDecoderStream * pDecoderStream); 12739 12740 void 12741 assimilateSubParameters ( 12742 CErrorDetails * pError); 12743 12744 void 12745 encode ( 12746 CEncoderStream * pEncoderStream) const; 12747 12748 12749 llrp_bool_t 12750 isAllowedIn ( 12751 const CTypeDescriptor * pEnclosingElementType) const; 12752 12753 12754 static CElement * 12755 s_construct (void); 12756 12757 static void 12758 s_decodeFields ( 12759 CDecoderStream * pDecoderStream, 12760 CElement * pElement); 12762 12763 12764 12765 protected: 12766 std::list<CEPCData *> m_listEPCData; 12767 12768 public: 12770 inline std::list<CEPCData *>::iterator 12771 beginEPCData (void) 12772 { 12773 return m_listEPCData.begin(); 12774 } 12775 12777 inline std::list<CEPCData *>::iterator 12778 endEPCData (void) 12779 { 12780 return m_listEPCData.end(); 12781 } 12782 12784 inline void 12785 clearEPCData (void) 12786 { 12787 clearSubParameterList ((tListOfParameters *) &m_listEPCData); 12788 } 12789 12791 inline int 12792 countEPCData (void) 12793 { 12794 return (int) (m_listEPCData.size()); 12795 } 12796 12797 EResultCode 12799 addEPCData ( 12800 CEPCData * pValue); 12801 12802 12803 protected: 12804 CImpinjLocationReportData * m_pImpinjLocationReportData; 12805 12806 public: 12808 inline CImpinjLocationReportData * 12809 getImpinjLocationReportData (void) 12810 { 12811 return m_pImpinjLocationReportData; 12812 } 12813 12815 EResultCode 12816 setImpinjLocationReportData ( 12817 CImpinjLocationReportData * pValue); 12818 12819 12820 protected: 12821 CImpinjDirectionReportData * m_pImpinjDirectionReportData; 12822 12823 public: 12825 inline CImpinjDirectionReportData * 12826 getImpinjDirectionReportData (void) 12827 { 12828 return m_pImpinjDirectionReportData; 12829 } 12830 12832 EResultCode 12833 setImpinjDirectionReportData ( 12834 CImpinjDirectionReportData * pValue); 12835 12836 12837 protected: 12838 std::list<CParameter *> m_listCustom; 12839 12840 public: 12842 inline std::list<CParameter *>::iterator 12843 beginCustom (void) 12844 { 12845 return m_listCustom.begin(); 12846 } 12847 12849 inline std::list<CParameter *>::iterator 12850 endCustom (void) 12851 { 12852 return m_listCustom.end(); 12853 } 12854 12856 inline void 12857 clearCustom (void) 12858 { 12859 clearSubParameterList ((tListOfParameters *) &m_listCustom); 12860 } 12861 12863 inline int 12864 countCustom (void) 12865 { 12866 return (int) (m_listCustom.size()); 12867 } 12868 12869 EResultCode 12871 addCustom ( 12872 CParameter * pValue); 12873 12874 12875 }; 12876 12877 12924 class CImpinjDirectionReporting : public CParameter 12925 { 12926 public: 12927 CImpinjDirectionReporting (void); 12928 ~CImpinjDirectionReporting (void); 12929 12932 12933 static const CFieldDescriptor * const 12934 s_apFieldDescriptorTable[]; 12935 12936 static const CTypeDescriptor 12937 s_typeDescriptor; 12938 12939 void 12940 decodeFields ( 12941 CDecoderStream * pDecoderStream); 12942 12943 void 12944 assimilateSubParameters ( 12945 CErrorDetails * pError); 12946 12947 void 12948 encode ( 12949 CEncoderStream * pEncoderStream) const; 12950 12951 12952 llrp_bool_t 12953 isAllowedIn ( 12954 const CTypeDescriptor * pEnclosingElementType) const; 12955 12956 12957 static CElement * 12958 s_construct (void); 12959 12960 static void 12961 s_decodeFields ( 12962 CDecoderStream * pDecoderStream, 12963 CElement * pElement); 12965 12966 12967 protected: 12968 llrp_u1_t m_EnableUpdateReport; 12969 12972 public: 12973 static const CFieldDescriptor 12974 s_fdEnableUpdateReport; 12976 12978 inline llrp_u1_t 12979 getEnableUpdateReport (void) 12980 { 12981 return m_EnableUpdateReport; 12982 } 12983 12985 inline void 12986 setEnableUpdateReport ( 12987 llrp_u1_t value) 12988 { 12989 m_EnableUpdateReport = value; 12990 } 12991 12992 12993 protected: 12994 llrp_u1_t m_EnableEntryReport; 12995 12998 public: 12999 static const CFieldDescriptor 13000 s_fdEnableEntryReport; 13002 13004 inline llrp_u1_t 13005 getEnableEntryReport (void) 13006 { 13007 return m_EnableEntryReport; 13008 } 13009 13011 inline void 13012 setEnableEntryReport ( 13013 llrp_u1_t value) 13014 { 13015 m_EnableEntryReport = value; 13016 } 13017 13018 13019 protected: 13020 llrp_u1_t m_EnableExitReport; 13021 13024 public: 13025 static const CFieldDescriptor 13026 s_fdEnableExitReport; 13028 13030 inline llrp_u1_t 13031 getEnableExitReport (void) 13032 { 13033 return m_EnableExitReport; 13034 } 13035 13037 inline void 13038 setEnableExitReport ( 13039 llrp_u1_t value) 13040 { 13041 m_EnableExitReport = value; 13042 } 13043 13044 13045 protected: 13046 llrp_u1_t m_EnableDiagnosticReport; 13047 13050 public: 13051 static const CFieldDescriptor 13052 s_fdEnableDiagnosticReport; 13054 13056 inline llrp_u1_t 13057 getEnableDiagnosticReport (void) 13058 { 13059 return m_EnableDiagnosticReport; 13060 } 13061 13063 inline void 13064 setEnableDiagnosticReport ( 13065 llrp_u1_t value) 13066 { 13067 m_EnableDiagnosticReport = value; 13068 } 13069 13070 13071 protected: 13072 EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel; 13073 13076 public: 13077 static const CFieldDescriptor 13078 s_fdDiagnosticReportLevel; 13080 13082 inline EImpinjDirectionDiagnosticReportLevel 13083 getDiagnosticReportLevel (void) 13084 { 13085 return m_eDiagnosticReportLevel; 13086 } 13087 13089 inline void 13090 setDiagnosticReportLevel ( 13091 EImpinjDirectionDiagnosticReportLevel value) 13092 { 13093 m_eDiagnosticReportLevel = value; 13094 } 13095 13096 13097 13098 protected: 13099 std::list<CParameter *> m_listCustom; 13100 13101 public: 13103 inline std::list<CParameter *>::iterator 13104 beginCustom (void) 13105 { 13106 return m_listCustom.begin(); 13107 } 13108 13110 inline std::list<CParameter *>::iterator 13111 endCustom (void) 13112 { 13113 return m_listCustom.end(); 13114 } 13115 13117 inline void 13118 clearCustom (void) 13119 { 13120 clearSubParameterList ((tListOfParameters *) &m_listCustom); 13121 } 13122 13124 inline int 13125 countCustom (void) 13126 { 13127 return (int) (m_listCustom.size()); 13128 } 13129 13130 EResultCode 13132 addCustom ( 13133 CParameter * pValue); 13134 13135 13136 }; 13137 13138 13186 class CImpinjDirectionReportData : public CParameter 13187 { 13188 public: 13189 CImpinjDirectionReportData (void); 13190 ~CImpinjDirectionReportData (void); 13191 13194 13195 static const CFieldDescriptor * const 13196 s_apFieldDescriptorTable[]; 13197 13198 static const CTypeDescriptor 13199 s_typeDescriptor; 13200 13201 void 13202 decodeFields ( 13203 CDecoderStream * pDecoderStream); 13204 13205 void 13206 assimilateSubParameters ( 13207 CErrorDetails * pError); 13208 13209 void 13210 encode ( 13211 CEncoderStream * pEncoderStream) const; 13212 13213 13214 llrp_bool_t 13215 isAllowedIn ( 13216 const CTypeDescriptor * pEnclosingElementType) const; 13217 13218 13219 static CElement * 13220 s_construct (void); 13221 13222 static void 13223 s_decodeFields ( 13224 CDecoderStream * pDecoderStream, 13225 CElement * pElement); 13227 13228 13229 protected: 13230 EImpinjDirectionReportType m_eType; 13231 13234 public: 13235 static const CFieldDescriptor 13236 s_fdType; 13238 13240 inline EImpinjDirectionReportType 13241 getType (void) 13242 { 13243 return m_eType; 13244 } 13245 13247 inline void 13248 setType ( 13249 EImpinjDirectionReportType value) 13250 { 13251 m_eType = value; 13252 } 13253 13254 13255 protected: 13256 EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus; 13257 13260 public: 13261 static const CFieldDescriptor 13262 s_fdTagPopulationStatus; 13264 13266 inline EImpinjDirectionTagPopulationStatus 13267 getTagPopulationStatus (void) 13268 { 13269 return m_eTagPopulationStatus; 13270 } 13271 13273 inline void 13274 setTagPopulationStatus ( 13275 EImpinjDirectionTagPopulationStatus value) 13276 { 13277 m_eTagPopulationStatus = value; 13278 } 13279 13280 13281 protected: 13282 llrp_u8_t m_FirstSeenSectorID; 13283 13286 public: 13287 static const CFieldDescriptor 13288 s_fdFirstSeenSectorID; 13290 13292 inline llrp_u8_t 13293 getFirstSeenSectorID (void) 13294 { 13295 return m_FirstSeenSectorID; 13296 } 13297 13299 inline void 13300 setFirstSeenSectorID ( 13301 llrp_u8_t value) 13302 { 13303 m_FirstSeenSectorID = value; 13304 } 13305 13306 13307 protected: 13308 llrp_u64_t m_FirstSeenTimestampUTC; 13309 13312 public: 13313 static const CFieldDescriptor 13314 s_fdFirstSeenTimestampUTC; 13316 13318 inline llrp_u64_t 13319 getFirstSeenTimestampUTC (void) 13320 { 13321 return m_FirstSeenTimestampUTC; 13322 } 13323 13325 inline void 13326 setFirstSeenTimestampUTC ( 13327 llrp_u64_t value) 13328 { 13329 m_FirstSeenTimestampUTC = value; 13330 } 13331 13332 13333 protected: 13334 llrp_u8_t m_LastSeenSectorID; 13335 13338 public: 13339 static const CFieldDescriptor 13340 s_fdLastSeenSectorID; 13342 13344 inline llrp_u8_t 13345 getLastSeenSectorID (void) 13346 { 13347 return m_LastSeenSectorID; 13348 } 13349 13351 inline void 13352 setLastSeenSectorID ( 13353 llrp_u8_t value) 13354 { 13355 m_LastSeenSectorID = value; 13356 } 13357 13358 13359 protected: 13360 llrp_u64_t m_LastSeenTimestampUTC; 13361 13364 public: 13365 static const CFieldDescriptor 13366 s_fdLastSeenTimestampUTC; 13368 13370 inline llrp_u64_t 13371 getLastSeenTimestampUTC (void) 13372 { 13373 return m_LastSeenTimestampUTC; 13374 } 13375 13377 inline void 13378 setLastSeenTimestampUTC ( 13379 llrp_u64_t value) 13380 { 13381 m_LastSeenTimestampUTC = value; 13382 } 13383 13384 13385 13386 protected: 13387 CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData; 13388 13389 public: 13391 inline CImpinjDirectionDiagnosticData * 13392 getImpinjDirectionDiagnosticData (void) 13393 { 13394 return m_pImpinjDirectionDiagnosticData; 13395 } 13396 13398 EResultCode 13399 setImpinjDirectionDiagnosticData ( 13400 CImpinjDirectionDiagnosticData * pValue); 13401 13402 13403 protected: 13404 std::list<CParameter *> m_listCustom; 13405 13406 public: 13408 inline std::list<CParameter *>::iterator 13409 beginCustom (void) 13410 { 13411 return m_listCustom.begin(); 13412 } 13413 13415 inline std::list<CParameter *>::iterator 13416 endCustom (void) 13417 { 13418 return m_listCustom.end(); 13419 } 13420 13422 inline void 13423 clearCustom (void) 13424 { 13425 clearSubParameterList ((tListOfParameters *) &m_listCustom); 13426 } 13427 13429 inline int 13430 countCustom (void) 13431 { 13432 return (int) (m_listCustom.size()); 13433 } 13434 13435 EResultCode 13437 addCustom ( 13438 CParameter * pValue); 13439 13440 13441 }; 13442 13443 13466 class CImpinjDirectionDiagnosticData : public CParameter 13467 { 13468 public: 13469 CImpinjDirectionDiagnosticData (void); 13470 ~CImpinjDirectionDiagnosticData (void); 13471 13474 13475 static const CFieldDescriptor * const 13476 s_apFieldDescriptorTable[]; 13477 13478 static const CTypeDescriptor 13479 s_typeDescriptor; 13480 13481 void 13482 decodeFields ( 13483 CDecoderStream * pDecoderStream); 13484 13485 void 13486 assimilateSubParameters ( 13487 CErrorDetails * pError); 13488 13489 void 13490 encode ( 13491 CEncoderStream * pEncoderStream) const; 13492 13493 13494 llrp_bool_t 13495 isAllowedIn ( 13496 const CTypeDescriptor * pEnclosingElementType) const; 13497 13498 13499 static CElement * 13500 s_construct (void); 13501 13502 static void 13503 s_decodeFields ( 13504 CDecoderStream * pDecoderStream, 13505 CElement * pElement); 13507 13508 13509 protected: 13510 llrp_u32v_t m_Metric; 13511 13514 public: 13515 static const CFieldDescriptor 13516 s_fdMetric; 13518 13520 inline llrp_u32v_t 13521 getMetric (void) 13522 { 13523 return m_Metric; 13524 } 13525 13527 inline void 13528 setMetric ( 13529 llrp_u32v_t value) 13530 { 13531 m_Metric = value; 13532 } 13533 13534 13535 13536 }; 13537 13538 13563 class CImpinjxArrayDirectionCapabilities : public CParameter 13564 { 13565 public: 13566 CImpinjxArrayDirectionCapabilities (void); 13567 ~CImpinjxArrayDirectionCapabilities (void); 13568 13571 13572 static const CFieldDescriptor * const 13573 s_apFieldDescriptorTable[]; 13574 13575 static const CTypeDescriptor 13576 s_typeDescriptor; 13577 13578 void 13579 decodeFields ( 13580 CDecoderStream * pDecoderStream); 13581 13582 void 13583 assimilateSubParameters ( 13584 CErrorDetails * pError); 13585 13586 void 13587 encode ( 13588 CEncoderStream * pEncoderStream) const; 13589 13590 13591 llrp_bool_t 13592 isAllowedIn ( 13593 const CTypeDescriptor * pEnclosingElementType) const; 13594 13595 13596 static CElement * 13597 s_construct (void); 13598 13599 static void 13600 s_decodeFields ( 13601 CDecoderStream * pDecoderStream, 13602 CElement * pElement); 13604 13605 13606 protected: 13607 llrp_u16_t m_SystemTagPopulationLimitHighSensitivity; 13608 13611 public: 13612 static const CFieldDescriptor 13613 s_fdSystemTagPopulationLimitHighSensitivity; 13615 13617 inline llrp_u16_t 13618 getSystemTagPopulationLimitHighSensitivity (void) 13619 { 13620 return m_SystemTagPopulationLimitHighSensitivity; 13621 } 13622 13624 inline void 13625 setSystemTagPopulationLimitHighSensitivity ( 13626 llrp_u16_t value) 13627 { 13628 m_SystemTagPopulationLimitHighSensitivity = value; 13629 } 13630 13631 13632 protected: 13633 llrp_u16_t m_SystemTagPopulationLimitHighPerformance; 13634 13637 public: 13638 static const CFieldDescriptor 13639 s_fdSystemTagPopulationLimitHighPerformance; 13641 13643 inline llrp_u16_t 13644 getSystemTagPopulationLimitHighPerformance (void) 13645 { 13646 return m_SystemTagPopulationLimitHighPerformance; 13647 } 13648 13650 inline void 13651 setSystemTagPopulationLimitHighPerformance ( 13652 llrp_u16_t value) 13653 { 13654 m_SystemTagPopulationLimitHighPerformance = value; 13655 } 13656 13657 13658 13659 protected: 13660 std::list<CParameter *> m_listCustom; 13661 13662 public: 13664 inline std::list<CParameter *>::iterator 13665 beginCustom (void) 13666 { 13667 return m_listCustom.begin(); 13668 } 13669 13671 inline std::list<CParameter *>::iterator 13672 endCustom (void) 13673 { 13674 return m_listCustom.end(); 13675 } 13676 13678 inline void 13679 clearCustom (void) 13680 { 13681 clearSubParameterList ((tListOfParameters *) &m_listCustom); 13682 } 13683 13685 inline int 13686 countCustom (void) 13687 { 13688 return (int) (m_listCustom.size()); 13689 } 13690 13691 EResultCode 13693 addCustom ( 13694 CParameter * pValue); 13695 13696 13697 }; 13698 13699 13725 class CImpinjIntelligentAntennaManagement : public CParameter 13726 { 13727 public: 13728 CImpinjIntelligentAntennaManagement (void); 13729 ~CImpinjIntelligentAntennaManagement (void); 13730 13733 13734 static const CFieldDescriptor * const 13735 s_apFieldDescriptorTable[]; 13736 13737 static const CTypeDescriptor 13738 s_typeDescriptor; 13739 13740 void 13741 decodeFields ( 13742 CDecoderStream * pDecoderStream); 13743 13744 void 13745 assimilateSubParameters ( 13746 CErrorDetails * pError); 13747 13748 void 13749 encode ( 13750 CEncoderStream * pEncoderStream) const; 13751 13752 13753 llrp_bool_t 13754 isAllowedIn ( 13755 const CTypeDescriptor * pEnclosingElementType) const; 13756 13757 13758 static CElement * 13759 s_construct (void); 13760 13761 static void 13762 s_decodeFields ( 13763 CDecoderStream * pDecoderStream, 13764 CElement * pElement); 13766 13767 13768 protected: 13769 EImpinjIntelligentAntennaMode m_eManagementEnabled; 13770 13773 public: 13774 static const CFieldDescriptor 13775 s_fdManagementEnabled; 13777 13779 inline EImpinjIntelligentAntennaMode 13780 getManagementEnabled (void) 13781 { 13782 return m_eManagementEnabled; 13783 } 13784 13786 inline void 13787 setManagementEnabled ( 13788 EImpinjIntelligentAntennaMode value) 13789 { 13790 m_eManagementEnabled = value; 13791 } 13792 13793 13794 13795 protected: 13796 std::list<CParameter *> m_listCustom; 13797 13798 public: 13800 inline std::list<CParameter *>::iterator 13801 beginCustom (void) 13802 { 13803 return m_listCustom.begin(); 13804 } 13805 13807 inline std::list<CParameter *>::iterator 13808 endCustom (void) 13809 { 13810 return m_listCustom.end(); 13811 } 13812 13814 inline void 13815 clearCustom (void) 13816 { 13817 clearSubParameterList ((tListOfParameters *) &m_listCustom); 13818 } 13819 13821 inline int 13822 countCustom (void) 13823 { 13824 return (int) (m_listCustom.size()); 13825 } 13826 13827 EResultCode 13829 addCustom ( 13830 CParameter * pValue); 13831 13832 13833 }; 13834 13835 13862 class CImpinjTransmitPower : public CParameter 13863 { 13864 public: 13865 CImpinjTransmitPower (void); 13866 ~CImpinjTransmitPower (void); 13867 13870 13871 static const CFieldDescriptor * const 13872 s_apFieldDescriptorTable[]; 13873 13874 static const CTypeDescriptor 13875 s_typeDescriptor; 13876 13877 void 13878 decodeFields ( 13879 CDecoderStream * pDecoderStream); 13880 13881 void 13882 assimilateSubParameters ( 13883 CErrorDetails * pError); 13884 13885 void 13886 encode ( 13887 CEncoderStream * pEncoderStream) const; 13888 13889 13890 llrp_bool_t 13891 isAllowedIn ( 13892 const CTypeDescriptor * pEnclosingElementType) const; 13893 13894 13895 static CElement * 13896 s_construct (void); 13897 13898 static void 13899 s_decodeFields ( 13900 CDecoderStream * pDecoderStream, 13901 CElement * pElement); 13903 13904 13905 protected: 13906 llrp_u16_t m_TransmitPower; 13907 13910 public: 13911 static const CFieldDescriptor 13912 s_fdTransmitPower; 13914 13916 inline llrp_u16_t 13917 getTransmitPower (void) 13918 { 13919 return m_TransmitPower; 13920 } 13921 13923 inline void 13924 setTransmitPower ( 13925 llrp_u16_t value) 13926 { 13927 m_TransmitPower = value; 13928 } 13929 13930 13931 13932 protected: 13933 std::list<CParameter *> m_listCustom; 13934 13935 public: 13937 inline std::list<CParameter *>::iterator 13938 beginCustom (void) 13939 { 13940 return m_listCustom.begin(); 13941 } 13942 13944 inline std::list<CParameter *>::iterator 13945 endCustom (void) 13946 { 13947 return m_listCustom.end(); 13948 } 13949 13951 inline void 13952 clearCustom (void) 13953 { 13954 clearSubParameterList ((tListOfParameters *) &m_listCustom); 13955 } 13956 13958 inline int 13959 countCustom (void) 13960 { 13961 return (int) (m_listCustom.size()); 13962 } 13963 13964 EResultCode 13966 addCustom ( 13967 CParameter * pValue); 13968 13969 13970 }; 13971 13972 13999 class CImpinjPolarizationControl : public CParameter 14000 { 14001 public: 14002 CImpinjPolarizationControl (void); 14003 ~CImpinjPolarizationControl (void); 14004 14007 14008 static const CFieldDescriptor * const 14009 s_apFieldDescriptorTable[]; 14010 14011 static const CTypeDescriptor 14012 s_typeDescriptor; 14013 14014 void 14015 decodeFields ( 14016 CDecoderStream * pDecoderStream); 14017 14018 void 14019 assimilateSubParameters ( 14020 CErrorDetails * pError); 14021 14022 void 14023 encode ( 14024 CEncoderStream * pEncoderStream) const; 14025 14026 14027 llrp_bool_t 14028 isAllowedIn ( 14029 const CTypeDescriptor * pEnclosingElementType) const; 14030 14031 14032 static CElement * 14033 s_construct (void); 14034 14035 static void 14036 s_decodeFields ( 14037 CDecoderStream * pDecoderStream, 14038 CElement * pElement); 14040 14041 14042 protected: 14043 llrp_u1_t m_PolarizationControlEnabled; 14044 14047 public: 14048 static const CFieldDescriptor 14049 s_fdPolarizationControlEnabled; 14051 14053 inline llrp_u1_t 14054 getPolarizationControlEnabled (void) 14055 { 14056 return m_PolarizationControlEnabled; 14057 } 14058 14060 inline void 14061 setPolarizationControlEnabled ( 14062 llrp_u1_t value) 14063 { 14064 m_PolarizationControlEnabled = value; 14065 } 14066 14067 14068 14069 protected: 14070 std::list<CParameter *> m_listCustom; 14071 14072 public: 14074 inline std::list<CParameter *>::iterator 14075 beginCustom (void) 14076 { 14077 return m_listCustom.begin(); 14078 } 14079 14081 inline std::list<CParameter *>::iterator 14082 endCustom (void) 14083 { 14084 return m_listCustom.end(); 14085 } 14086 14088 inline void 14089 clearCustom (void) 14090 { 14091 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14092 } 14093 14095 inline int 14096 countCustom (void) 14097 { 14098 return (int) (m_listCustom.size()); 14099 } 14100 14101 EResultCode 14103 addCustom ( 14104 CParameter * pValue); 14105 14106 14107 }; 14108 14109 14134 class CImpinjAntennaCapabilities : public CParameter 14135 { 14136 public: 14137 CImpinjAntennaCapabilities (void); 14138 ~CImpinjAntennaCapabilities (void); 14139 14142 14143 static const CFieldDescriptor * const 14144 s_apFieldDescriptorTable[]; 14145 14146 static const CTypeDescriptor 14147 s_typeDescriptor; 14148 14149 void 14150 decodeFields ( 14151 CDecoderStream * pDecoderStream); 14152 14153 void 14154 assimilateSubParameters ( 14155 CErrorDetails * pError); 14156 14157 void 14158 encode ( 14159 CEncoderStream * pEncoderStream) const; 14160 14161 14162 llrp_bool_t 14163 isAllowedIn ( 14164 const CTypeDescriptor * pEnclosingElementType) const; 14165 14166 14167 static CElement * 14168 s_construct (void); 14169 14170 static void 14171 s_decodeFields ( 14172 CDecoderStream * pDecoderStream, 14173 CElement * pElement); 14175 14176 14177 14178 protected: 14179 std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability; 14180 14181 public: 14183 inline std::list<CImpinjAntennaPolarizationCapability *>::iterator 14184 beginImpinjAntennaPolarizationCapability (void) 14185 { 14186 return m_listImpinjAntennaPolarizationCapability.begin(); 14187 } 14188 14190 inline std::list<CImpinjAntennaPolarizationCapability *>::iterator 14191 endImpinjAntennaPolarizationCapability (void) 14192 { 14193 return m_listImpinjAntennaPolarizationCapability.end(); 14194 } 14195 14197 inline void 14198 clearImpinjAntennaPolarizationCapability (void) 14199 { 14200 clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability); 14201 } 14202 14204 inline int 14205 countImpinjAntennaPolarizationCapability (void) 14206 { 14207 return (int) (m_listImpinjAntennaPolarizationCapability.size()); 14208 } 14209 14210 EResultCode 14212 addImpinjAntennaPolarizationCapability ( 14213 CImpinjAntennaPolarizationCapability * pValue); 14214 14215 14216 protected: 14217 std::list<CParameter *> m_listCustom; 14218 14219 public: 14221 inline std::list<CParameter *>::iterator 14222 beginCustom (void) 14223 { 14224 return m_listCustom.begin(); 14225 } 14226 14228 inline std::list<CParameter *>::iterator 14229 endCustom (void) 14230 { 14231 return m_listCustom.end(); 14232 } 14233 14235 inline void 14236 clearCustom (void) 14237 { 14238 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14239 } 14240 14242 inline int 14243 countCustom (void) 14244 { 14245 return (int) (m_listCustom.size()); 14246 } 14247 14248 EResultCode 14250 addCustom ( 14251 CParameter * pValue); 14252 14253 14254 }; 14255 14256 14281 class CImpinjAntennaPolarizationCapability : public CParameter 14282 { 14283 public: 14284 CImpinjAntennaPolarizationCapability (void); 14285 ~CImpinjAntennaPolarizationCapability (void); 14286 14289 14290 static const CFieldDescriptor * const 14291 s_apFieldDescriptorTable[]; 14292 14293 static const CTypeDescriptor 14294 s_typeDescriptor; 14295 14296 void 14297 decodeFields ( 14298 CDecoderStream * pDecoderStream); 14299 14300 void 14301 assimilateSubParameters ( 14302 CErrorDetails * pError); 14303 14304 void 14305 encode ( 14306 CEncoderStream * pEncoderStream) const; 14307 14308 14309 llrp_bool_t 14310 isAllowedIn ( 14311 const CTypeDescriptor * pEnclosingElementType) const; 14312 14313 14314 static CElement * 14315 s_construct (void); 14316 14317 static void 14318 s_decodeFields ( 14319 CDecoderStream * pDecoderStream, 14320 CElement * pElement); 14322 14323 14324 protected: 14325 EImpinjAntennaPolarizationType m_eType; 14326 14329 public: 14330 static const CFieldDescriptor 14331 s_fdType; 14333 14335 inline EImpinjAntennaPolarizationType 14336 getType (void) 14337 { 14338 return m_eType; 14339 } 14340 14342 inline void 14343 setType ( 14344 EImpinjAntennaPolarizationType value) 14345 { 14346 m_eType = value; 14347 } 14348 14349 14350 protected: 14351 llrp_u16_t m_AntennaIDOffset; 14352 14355 public: 14356 static const CFieldDescriptor 14357 s_fdAntennaIDOffset; 14359 14361 inline llrp_u16_t 14362 getAntennaIDOffset (void) 14363 { 14364 return m_AntennaIDOffset; 14365 } 14366 14368 inline void 14369 setAntennaIDOffset ( 14370 llrp_u16_t value) 14371 { 14372 m_AntennaIDOffset = value; 14373 } 14374 14375 14376 14377 protected: 14378 std::list<CParameter *> m_listCustom; 14379 14380 public: 14382 inline std::list<CParameter *>::iterator 14383 beginCustom (void) 14384 { 14385 return m_listCustom.begin(); 14386 } 14387 14389 inline std::list<CParameter *>::iterator 14390 endCustom (void) 14391 { 14392 return m_listCustom.end(); 14393 } 14394 14396 inline void 14397 clearCustom (void) 14398 { 14399 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14400 } 14401 14403 inline int 14404 countCustom (void) 14405 { 14406 return (int) (m_listCustom.size()); 14407 } 14408 14409 EResultCode 14411 addCustom ( 14412 CParameter * pValue); 14413 14414 14415 }; 14416 14417 14441 class CImpinjDisabledAntennas : public CParameter 14442 { 14443 public: 14444 CImpinjDisabledAntennas (void); 14445 ~CImpinjDisabledAntennas (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 llrp_bool_t 14470 isAllowedIn ( 14471 const CTypeDescriptor * pEnclosingElementType) const; 14472 14473 14474 static CElement * 14475 s_construct (void); 14476 14477 static void 14478 s_decodeFields ( 14479 CDecoderStream * pDecoderStream, 14480 CElement * pElement); 14482 14483 14484 protected: 14485 llrp_u16v_t m_AntennaIDs; 14486 14489 public: 14490 static const CFieldDescriptor 14491 s_fdAntennaIDs; 14493 14495 inline llrp_u16v_t 14496 getAntennaIDs (void) 14497 { 14498 return m_AntennaIDs; 14499 } 14500 14502 inline void 14503 setAntennaIDs ( 14504 llrp_u16v_t value) 14505 { 14506 m_AntennaIDs = value; 14507 } 14508 14509 14510 14511 protected: 14512 std::list<CParameter *> m_listCustom; 14513 14514 public: 14516 inline std::list<CParameter *>::iterator 14517 beginCustom (void) 14518 { 14519 return m_listCustom.begin(); 14520 } 14521 14523 inline std::list<CParameter *>::iterator 14524 endCustom (void) 14525 { 14526 return m_listCustom.end(); 14527 } 14528 14530 inline void 14531 clearCustom (void) 14532 { 14533 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14534 } 14535 14537 inline int 14538 countCustom (void) 14539 { 14540 return (int) (m_listCustom.size()); 14541 } 14542 14543 EResultCode 14545 addCustom ( 14546 CParameter * pValue); 14547 14548 14549 }; 14550 14551 14576 class CImpinjTIDParity : public CParameter 14577 { 14578 public: 14579 CImpinjTIDParity (void); 14580 ~CImpinjTIDParity (void); 14581 14584 14585 static const CFieldDescriptor * const 14586 s_apFieldDescriptorTable[]; 14587 14588 static const CTypeDescriptor 14589 s_typeDescriptor; 14590 14591 void 14592 decodeFields ( 14593 CDecoderStream * pDecoderStream); 14594 14595 void 14596 assimilateSubParameters ( 14597 CErrorDetails * pError); 14598 14599 void 14600 encode ( 14601 CEncoderStream * pEncoderStream) const; 14602 14603 14604 llrp_bool_t 14605 isAllowedIn ( 14606 const CTypeDescriptor * pEnclosingElementType) const; 14607 14608 14609 static CElement * 14610 s_construct (void); 14611 14612 static void 14613 s_decodeFields ( 14614 CDecoderStream * pDecoderStream, 14615 CElement * pElement); 14617 14618 14619 protected: 14620 llrp_u1_t m_ParityError; 14621 14624 public: 14625 static const CFieldDescriptor 14626 s_fdParityError; 14628 14630 inline llrp_u1_t 14631 getParityError (void) 14632 { 14633 return m_ParityError; 14634 } 14635 14637 inline void 14638 setParityError ( 14639 llrp_u1_t value) 14640 { 14641 m_ParityError = value; 14642 } 14643 14644 14645 14646 protected: 14647 std::list<CParameter *> m_listCustom; 14648 14649 public: 14651 inline std::list<CParameter *>::iterator 14652 beginCustom (void) 14653 { 14654 return m_listCustom.begin(); 14655 } 14656 14658 inline std::list<CParameter *>::iterator 14659 endCustom (void) 14660 { 14661 return m_listCustom.end(); 14662 } 14663 14665 inline void 14666 clearCustom (void) 14667 { 14668 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14669 } 14670 14672 inline int 14673 countCustom (void) 14674 { 14675 return (int) (m_listCustom.size()); 14676 } 14677 14678 EResultCode 14680 addCustom ( 14681 CParameter * pValue); 14682 14683 14684 }; 14685 14686 14717 class CImpinjMarginRead : public CParameter 14718 { 14719 public: 14720 CImpinjMarginRead (void); 14721 ~CImpinjMarginRead (void); 14722 14725 14726 static const CFieldDescriptor * const 14727 s_apFieldDescriptorTable[]; 14728 14729 static const CTypeDescriptor 14730 s_typeDescriptor; 14731 14732 void 14733 decodeFields ( 14734 CDecoderStream * pDecoderStream); 14735 14736 void 14737 assimilateSubParameters ( 14738 CErrorDetails * pError); 14739 14740 void 14741 encode ( 14742 CEncoderStream * pEncoderStream) const; 14743 14744 14745 llrp_bool_t 14746 isAllowedIn ( 14747 const CTypeDescriptor * pEnclosingElementType) const; 14748 14749 14750 static CElement * 14751 s_construct (void); 14752 14753 static void 14754 s_decodeFields ( 14755 CDecoderStream * pDecoderStream, 14756 CElement * pElement); 14758 14759 14760 protected: 14761 llrp_u16_t m_OpSpecID; 14762 14765 public: 14766 static const CFieldDescriptor 14767 s_fdOpSpecID; 14769 14771 inline llrp_u16_t 14772 getOpSpecID (void) 14773 { 14774 return m_OpSpecID; 14775 } 14776 14778 inline void 14779 setOpSpecID ( 14780 llrp_u16_t value) 14781 { 14782 m_OpSpecID = value; 14783 } 14784 14785 14786 protected: 14787 llrp_u32_t m_AccessPassword; 14788 14791 public: 14792 static const CFieldDescriptor 14793 s_fdAccessPassword; 14795 14797 inline llrp_u32_t 14798 getAccessPassword (void) 14799 { 14800 return m_AccessPassword; 14801 } 14802 14804 inline void 14805 setAccessPassword ( 14806 llrp_u32_t value) 14807 { 14808 m_AccessPassword = value; 14809 } 14810 14811 14812 protected: 14813 llrp_u2_t m_MB; 14814 14817 public: 14818 static const CFieldDescriptor 14819 s_fdMB; 14821 14823 inline llrp_u2_t 14824 getMB (void) 14825 { 14826 return m_MB; 14827 } 14828 14830 inline void 14831 setMB ( 14832 llrp_u2_t value) 14833 { 14834 m_MB = value; 14835 } 14836 14837 14838 protected: 14839 llrp_u16_t m_BitPointer; 14840 14843 public: 14844 static const CFieldDescriptor 14845 s_fdBitPointer; 14847 14849 inline llrp_u16_t 14850 getBitPointer (void) 14851 { 14852 return m_BitPointer; 14853 } 14854 14856 inline void 14857 setBitPointer ( 14858 llrp_u16_t value) 14859 { 14860 m_BitPointer = value; 14861 } 14862 14863 14864 protected: 14865 llrp_u8_t m_BitLength; 14866 14869 public: 14870 static const CFieldDescriptor 14871 s_fdBitLength; 14873 14875 inline llrp_u8_t 14876 getBitLength (void) 14877 { 14878 return m_BitLength; 14879 } 14880 14882 inline void 14883 setBitLength ( 14884 llrp_u8_t value) 14885 { 14886 m_BitLength = value; 14887 } 14888 14889 14890 protected: 14891 llrp_u16v_t m_Mask; 14892 14895 public: 14896 static const CFieldDescriptor 14897 s_fdMask; 14899 14901 inline llrp_u16v_t 14902 getMask (void) 14903 { 14904 return m_Mask; 14905 } 14906 14908 inline void 14909 setMask ( 14910 llrp_u16v_t value) 14911 { 14912 m_Mask = value; 14913 } 14914 14915 14916 14917 protected: 14918 std::list<CParameter *> m_listCustom; 14919 14920 public: 14922 inline std::list<CParameter *>::iterator 14923 beginCustom (void) 14924 { 14925 return m_listCustom.begin(); 14926 } 14927 14929 inline std::list<CParameter *>::iterator 14930 endCustom (void) 14931 { 14932 return m_listCustom.end(); 14933 } 14934 14936 inline void 14937 clearCustom (void) 14938 { 14939 clearSubParameterList ((tListOfParameters *) &m_listCustom); 14940 } 14941 14943 inline int 14944 countCustom (void) 14945 { 14946 return (int) (m_listCustom.size()); 14947 } 14948 14949 EResultCode 14951 addCustom ( 14952 CParameter * pValue); 14953 14954 14955 }; 14956 14957 14983 class CImpinjMarginReadOpSpecResult : public CParameter 14984 { 14985 public: 14986 CImpinjMarginReadOpSpecResult (void); 14987 ~CImpinjMarginReadOpSpecResult (void); 14988 14991 14992 static const CFieldDescriptor * const 14993 s_apFieldDescriptorTable[]; 14994 14995 static const CTypeDescriptor 14996 s_typeDescriptor; 14997 14998 void 14999 decodeFields ( 15000 CDecoderStream * pDecoderStream); 15001 15002 void 15003 assimilateSubParameters ( 15004 CErrorDetails * pError); 15005 15006 void 15007 encode ( 15008 CEncoderStream * pEncoderStream) const; 15009 15010 15011 llrp_bool_t 15012 isAllowedIn ( 15013 const CTypeDescriptor * pEnclosingElementType) const; 15014 15015 15016 static CElement * 15017 s_construct (void); 15018 15019 static void 15020 s_decodeFields ( 15021 CDecoderStream * pDecoderStream, 15022 CElement * pElement); 15024 15025 15026 protected: 15027 EImpinjMarginReadResultType m_eResult; 15028 15031 public: 15032 static const CFieldDescriptor 15033 s_fdResult; 15035 15037 inline EImpinjMarginReadResultType 15038 getResult (void) 15039 { 15040 return m_eResult; 15041 } 15042 15044 inline void 15045 setResult ( 15046 EImpinjMarginReadResultType value) 15047 { 15048 m_eResult = value; 15049 } 15050 15051 15052 protected: 15053 llrp_u16_t m_OpSpecID; 15054 15057 public: 15058 static const CFieldDescriptor 15059 s_fdOpSpecID; 15061 15063 inline llrp_u16_t 15064 getOpSpecID (void) 15065 { 15066 return m_OpSpecID; 15067 } 15068 15070 inline void 15071 setOpSpecID ( 15072 llrp_u16_t value) 15073 { 15074 m_OpSpecID = value; 15075 } 15076 15077 15078 15079 protected: 15080 std::list<CParameter *> m_listCustom; 15081 15082 public: 15084 inline std::list<CParameter *>::iterator 15085 beginCustom (void) 15086 { 15087 return m_listCustom.begin(); 15088 } 15089 15091 inline std::list<CParameter *>::iterator 15092 endCustom (void) 15093 { 15094 return m_listCustom.end(); 15095 } 15096 15098 inline void 15099 clearCustom (void) 15100 { 15101 clearSubParameterList ((tListOfParameters *) &m_listCustom); 15102 } 15103 15105 inline int 15106 countCustom (void) 15107 { 15108 return (int) (m_listCustom.size()); 15109 } 15110 15111 EResultCode 15113 addCustom ( 15114 CParameter * pValue); 15115 15116 15117 }; 15118 15119 15144 class CImpinjBLEVersion : public CParameter 15145 { 15146 public: 15147 CImpinjBLEVersion (void); 15148 ~CImpinjBLEVersion (void); 15149 15152 15153 static const CFieldDescriptor * const 15154 s_apFieldDescriptorTable[]; 15155 15156 static const CTypeDescriptor 15157 s_typeDescriptor; 15158 15159 void 15160 decodeFields ( 15161 CDecoderStream * pDecoderStream); 15162 15163 void 15164 assimilateSubParameters ( 15165 CErrorDetails * pError); 15166 15167 void 15168 encode ( 15169 CEncoderStream * pEncoderStream) const; 15170 15171 15172 llrp_bool_t 15173 isAllowedIn ( 15174 const CTypeDescriptor * pEnclosingElementType) const; 15175 15176 15177 static CElement * 15178 s_construct (void); 15179 15180 static void 15181 s_decodeFields ( 15182 CDecoderStream * pDecoderStream, 15183 CElement * pElement); 15185 15186 15187 protected: 15188 llrp_utf8v_t m_FirmwareVersion; 15189 15192 public: 15193 static const CFieldDescriptor 15194 s_fdFirmwareVersion; 15196 15198 inline llrp_utf8v_t 15199 getFirmwareVersion (void) 15200 { 15201 return m_FirmwareVersion; 15202 } 15203 15205 inline void 15206 setFirmwareVersion ( 15207 llrp_utf8v_t value) 15208 { 15209 m_FirmwareVersion = value; 15210 } 15211 15212 15213 15214 protected: 15215 std::list<CParameter *> m_listCustom; 15216 15217 public: 15219 inline std::list<CParameter *>::iterator 15220 beginCustom (void) 15221 { 15222 return m_listCustom.begin(); 15223 } 15224 15226 inline std::list<CParameter *>::iterator 15227 endCustom (void) 15228 { 15229 return m_listCustom.end(); 15230 } 15231 15233 inline void 15234 clearCustom (void) 15235 { 15236 clearSubParameterList ((tListOfParameters *) &m_listCustom); 15237 } 15238 15240 inline int 15241 countCustom (void) 15242 { 15243 return (int) (m_listCustom.size()); 15244 } 15245 15246 EResultCode 15248 addCustom ( 15249 CParameter * pValue); 15250 15251 15252 }; 15253 15254 15269 extern void 15270 enrollImpinjTypesIntoRegistry ( 15271 CTypeRegistry * pTypeRegistry);