LTKCPP-- LLRP Toolkit C Plus Plus Library
Library/Impinj/out_impinj_ltkcpp.h
00001 
00002 /*
00003  * Generated file - DO NOT EDIT
00004  *
00005  * This is the header file for the LLRP Tool Kit (LTK)
00006  * C++ (aka cpp) implementation. It is generated into a .inc file
00007  * that is included by a platform specific .h header file.
00008  * That .h file takes care of prerequisites needed by this file.
00009  */
00010 
00011 
00012 /*
00013  * Message classes - forward decls
00014  */
00015 
00016 
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);