LTKCPP-- LLRP Toolkit C Plus Plus Library
x86_64/src/generated/out_impinj_ltkcpp.h
1 
2 /*
3  * Generated file - DO NOT EDIT
4  *
5  * This is the header file for the LLRP Tool Kit (LTK)
6  * C++ (aka cpp) implementation. It is generated into a .inc file
7  * that is included by a platform specific .h header file.
8  * That .h file takes care of prerequisites needed by this file.
9  */
10 
11 
12 /*
13  * Message classes - forward decls
14  */
15 
16 
17 /* Custom messages */
18 
23 
24 /*
25  * Parameter classes - forward decls
26  */
27 
28 
29 /* Custom parameters */
30 
37 class CImpinjHubVersions;
50 class CImpinjSetQTConfig;
52 class CImpinjGetQTConfig;
61 class CImpinjPeakRSSI;
63 class CImpinjLoopSpec;
65 class CImpinjGGASentence;
66 class CImpinjRMCSentence;
75 class CImpinjTxPower;
87 class CImpinjLISpec;
93 class CImpinjDISpec;
109 class CImpinjTIDParity;
110 class CImpinjMarginRead;
112 class CImpinjBLEVersion;
114 class CImpinjRFPowerSweep;
116 class CImpinjAuthenticate;
118 
119 /*
120  * Vendor descriptor declarations.
121  */
122 
123 extern const CVendorDescriptor
124 g_vdescImpinj;
125 
126 
127 /*
128  * Namespace descriptor declarations.
129  */
130 
131 extern const CNamespaceDescriptor
132 g_nsdescImpinj;
133 
134 
135 /*
136  * Enumeration definitions and declarations of
137  * enumeration string tables.
138  */
139 
140 
172 enum EImpinjRequestedDataType
173 {
174 
175  ImpinjRequestedDataType_All_Capabilities = 1000,
176  ImpinjRequestedDataType_Impinj_Detailed_Version = 1001,
177  ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002,
178  ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003,
179  ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004,
180  ImpinjRequestedDataType_All_Configuration = 2000,
181  ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001,
182  ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003,
183  ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004,
184  ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005,
185  ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006,
186  ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007,
187  ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008,
188  ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009,
189  ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010,
190  ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011,
191  ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012,
192  ImpinjRequestedDataType_Impinj_Location_Configuration = 2013,
193  ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014,
194  ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015,
195  ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017,
196  ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018,
197 };
198 
199 extern const SEnumTableEntry
200 g_estImpinjRequestedDataType[];
201 
202 
239 enum EImpinjRegulatoryRegion
240 {
241 
242  ImpinjRegulatoryRegion_FCC_Part_15_247 = 0,
243  ImpinjRegulatoryRegion_ETSI_EN_300_220 = 1,
244  ImpinjRegulatoryRegion_ETSI_EN_302_208_With_LBT = 2,
245  ImpinjRegulatoryRegion_Hong_Kong_920_925_MHz = 3,
246  ImpinjRegulatoryRegion_Taiwan_922_928_MHz = 4,
247  ImpinjRegulatoryRegion_ETSI_EN_302_208_v1_2_1 = 7,
248  ImpinjRegulatoryRegion_Korea_917_921_MHz = 8,
249  ImpinjRegulatoryRegion_Malaysia_919_923_MHz = 9,
250  ImpinjRegulatoryRegion_China_920_925_MHz = 10,
251  ImpinjRegulatoryRegion_South_Africa_915_919_MHz = 12,
252  ImpinjRegulatoryRegion_Brazil_902_907_and_915_928_MHz = 13,
253  ImpinjRegulatoryRegion_Thailand_920_925_MHz = 14,
254  ImpinjRegulatoryRegion_Singapore_920_925_MHz = 15,
255  ImpinjRegulatoryRegion_Australia_920_926_MHz = 16,
256  ImpinjRegulatoryRegion_India_865_867_MHz = 17,
257  ImpinjRegulatoryRegion_Uruguay_916_928_MHz = 18,
258  ImpinjRegulatoryRegion_Vietnam_918_923_MHz = 19,
259  ImpinjRegulatoryRegion_Israel_915_917_MHz = 20,
260  ImpinjRegulatoryRegion_Philippines_918_920_MHz = 21,
261  ImpinjRegulatoryRegion_Vietnam_920_923_MHz = 22,
262  ImpinjRegulatoryRegion_Indonesia_920_923_MHz = 23,
263  ImpinjRegulatoryRegion_New_Zealand_921p5_928_MHz = 24,
264  ImpinjRegulatoryRegion_Japan_916_921_MHz_Without_LBT = 25,
265  ImpinjRegulatoryRegion_Latin_America_902_928_MHz = 26,
266  ImpinjRegulatoryRegion_Peru_916_928_MHz = 27,
267  ImpinjRegulatoryRegion_Bangladesh_925_927_MHz = 28,
268  ImpinjRegulatoryRegion_ETSI_915_921_MHz = 29,
269  ImpinjRegulatoryRegion_Morocco_867_868_MHz = 30,
270  ImpinjRegulatoryRegion_Paraguay_918_928_MHz = 31,
271 };
272 
273 extern const SEnumTableEntry
274 g_estImpinjRegulatoryRegion[];
275 
276 
291 enum EImpinjInventorySearchType
292 {
293 
294  ImpinjInventorySearchType_Reader_Selected = 0,
295  ImpinjInventorySearchType_Single_Target = 1,
296  ImpinjInventorySearchType_Dual_Target = 2,
297  ImpinjInventorySearchType_Single_Target_With_Suppression = 3,
298  ImpinjInventorySearchType_No_Target = 4,
299  ImpinjInventorySearchType_Single_Target_BtoA = 5,
300  ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6,
301 };
302 
303 extern const SEnumTableEntry
304 g_estImpinjInventorySearchType[];
305 
306 
317 enum EImpinjFixedFrequencyMode
318 {
319 
320  ImpinjFixedFrequencyMode_Disabled = 0,
321  ImpinjFixedFrequencyMode_Auto_Select = 1,
322  ImpinjFixedFrequencyMode_Channel_List = 2,
323 };
324 
325 extern const SEnumTableEntry
326 g_estImpinjFixedFrequencyMode[];
327 
328 
338 enum EImpinjReducedPowerMode
339 {
340 
341  ImpinjReducedPowerMode_Disabled = 0,
342  ImpinjReducedPowerMode_Enabled = 1,
343 };
344 
345 extern const SEnumTableEntry
346 g_estImpinjReducedPowerMode[];
347 
348 
358 enum EImpinjLowDutyCycleMode
359 {
360 
361  ImpinjLowDutyCycleMode_Disabled = 0,
362  ImpinjLowDutyCycleMode_Enabled = 1,
363 };
364 
365 extern const SEnumTableEntry
366 g_estImpinjLowDutyCycleMode[];
367 
368 
378 enum EImpinjLinkMonitorMode
379 {
380 
381  ImpinjLinkMonitorMode_Disabled = 0,
382  ImpinjLinkMonitorMode_Enabled = 1,
383 };
384 
385 extern const SEnumTableEntry
386 g_estImpinjLinkMonitorMode[];
387 
388 
398 enum EImpinjReportBufferMode
399 {
400 
401  ImpinjReportBufferMode_Normal = 0,
402  ImpinjReportBufferMode_Low_Latency = 1,
403 };
404 
405 extern const SEnumTableEntry
406 g_estImpinjReportBufferMode[];
407 
408 
423 enum EImpinjBlockPermalockResultType
424 {
425 
426  ImpinjBlockPermalockResultType_Success = 0,
427  ImpinjBlockPermalockResultType_Insufficient_Power = 1,
428  ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2,
429  ImpinjBlockPermalockResultType_No_Response_From_Tag = 3,
430  ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4,
431  ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5,
432  ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6,
433 };
434 
435 extern const SEnumTableEntry
436 g_estImpinjBlockPermalockResultType[];
437 
438 
452 enum EImpinjGetBlockPermalockStatusResultType
453 {
454 
455  ImpinjGetBlockPermalockStatusResultType_Success = 0,
456  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1,
457  ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2,
458  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3,
459  ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4,
460  ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5,
461 };
462 
463 extern const SEnumTableEntry
464 g_estImpinjGetBlockPermalockStatusResultType[];
465 
466 
477 enum EImpinjQTDataProfile
478 {
479 
480  ImpinjQTDataProfile_Unknown = 0,
481  ImpinjQTDataProfile_Private = 1,
482  ImpinjQTDataProfile_Public = 2,
483 };
484 
485 extern const SEnumTableEntry
486 g_estImpinjQTDataProfile[];
487 
488 
499 enum EImpinjQTAccessRange
500 {
501 
502  ImpinjQTAccessRange_Unknown = 0,
503  ImpinjQTAccessRange_Normal_Range = 1,
504  ImpinjQTAccessRange_Short_Range = 2,
505 };
506 
507 extern const SEnumTableEntry
508 g_estImpinjQTAccessRange[];
509 
510 
521 enum EImpinjQTPersistence
522 {
523 
524  ImpinjQTPersistence_Unknown = 0,
525  ImpinjQTPersistence_Temporary = 1,
526  ImpinjQTPersistence_Permanent = 2,
527 };
528 
529 extern const SEnumTableEntry
530 g_estImpinjQTPersistence[];
531 
532 
546 enum EImpinjSetQTConfigResultType
547 {
548 
549  ImpinjSetQTConfigResultType_Success = 0,
550  ImpinjSetQTConfigResultType_Insufficient_Power = 1,
551  ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2,
552  ImpinjSetQTConfigResultType_No_Response_From_Tag = 3,
553  ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4,
554  ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5,
555 };
556 
557 extern const SEnumTableEntry
558 g_estImpinjSetQTConfigResultType[];
559 
560 
573 enum EImpinjGetQTConfigResultType
574 {
575 
576  ImpinjGetQTConfigResultType_Success = 0,
577  ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1,
578  ImpinjGetQTConfigResultType_No_Response_From_Tag = 2,
579  ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3,
580  ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4,
581 };
582 
583 extern const SEnumTableEntry
584 g_estImpinjGetQTConfigResultType[];
585 
586 
596 enum EImpinjSerializedTIDMode
597 {
598 
599  ImpinjSerializedTIDMode_Disabled = 0,
600  ImpinjSerializedTIDMode_Enabled = 1,
601 };
602 
603 extern const SEnumTableEntry
604 g_estImpinjSerializedTIDMode[];
605 
606 
616 enum EImpinjRFPhaseAngleMode
617 {
618 
619  ImpinjRFPhaseAngleMode_Disabled = 0,
620  ImpinjRFPhaseAngleMode_Enabled = 1,
621 };
622 
623 extern const SEnumTableEntry
624 g_estImpinjRFPhaseAngleMode[];
625 
626 
636 enum EImpinjPeakRSSIMode
637 {
638 
639  ImpinjPeakRSSIMode_Disabled = 0,
640  ImpinjPeakRSSIMode_Enabled = 1,
641 };
642 
643 extern const SEnumTableEntry
644 g_estImpinjPeakRSSIMode[];
645 
646 
656 enum EImpinjGPSCoordinatesMode
657 {
658 
659  ImpinjGPSCoordinatesMode_Disabled = 0,
660  ImpinjGPSCoordinatesMode_Enabled = 1,
661 };
662 
663 extern const SEnumTableEntry
664 g_estImpinjGPSCoordinatesMode[];
665 
666 
681 enum EImpinjAdvancedGPOMode
682 {
683 
684  ImpinjAdvancedGPOMode_Normal = 0,
685  ImpinjAdvancedGPOMode_Pulsed = 1,
686  ImpinjAdvancedGPOMode_Reader_Operational_Status = 2,
687  ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3,
688  ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4,
689  ImpinjAdvancedGPOMode_Network_Connection_Status = 5,
690  ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6,
691 };
692 
693 extern const SEnumTableEntry
694 g_estImpinjAdvancedGPOMode[];
695 
696 
706 enum EImpinjOptimizedReadMode
707 {
708 
709  ImpinjOptimizedReadMode_Disabled = 0,
710  ImpinjOptimizedReadMode_Enabled = 1,
711 };
712 
713 extern const SEnumTableEntry
714 g_estImpinjOptimizedReadMode[];
715 
716 
726 enum EImpinjAccessSpecOrderingMode
727 {
728 
729  ImpinjAccessSpecOrderingMode_FIFO = 0,
730  ImpinjAccessSpecOrderingMode_Ascending = 1,
731 };
732 
733 extern const SEnumTableEntry
734 g_estImpinjAccessSpecOrderingMode[];
735 
736 
746 enum EImpinjRFDopplerFrequencyMode
747 {
748 
749  ImpinjRFDopplerFrequencyMode_Disabled = 0,
750  ImpinjRFDopplerFrequencyMode_Enabled = 1,
751 };
752 
753 extern const SEnumTableEntry
754 g_estImpinjRFDopplerFrequencyMode[];
755 
756 
766 enum EImpinjTxPowerReportingModeEnum
767 {
768 
769  ImpinjTxPowerReportingModeEnum_Disabled = 0,
770  ImpinjTxPowerReportingModeEnum_Enabled = 1,
771 };
772 
773 extern const SEnumTableEntry
774 g_estImpinjTxPowerReportingModeEnum[];
775 
776 
787 enum EImpinjHubConnectedType
788 {
789 
790  ImpinjHubConnectedType_Unknown = 0,
791  ImpinjHubConnectedType_Disconnected = 1,
792  ImpinjHubConnectedType_Connected = 2,
793 };
794 
795 extern const SEnumTableEntry
796 g_estImpinjHubConnectedType[];
797 
798 
815 enum EImpinjHubFaultType
816 {
817 
818  ImpinjHubFaultType_No_Fault = 0,
819  ImpinjHubFaultType_RF_Power = 1,
820  ImpinjHubFaultType_RF_Power_On_Hub_1 = 2,
821  ImpinjHubFaultType_RF_Power_On_Hub_2 = 3,
822  ImpinjHubFaultType_RF_Power_On_Hub_3 = 4,
823  ImpinjHubFaultType_RF_Power_On_Hub_4 = 5,
824  ImpinjHubFaultType_No_Init = 6,
825  ImpinjHubFaultType_Serial_Overflow = 7,
826  ImpinjHubFaultType_Disconnected = 8,
827 };
828 
829 extern const SEnumTableEntry
830 g_estImpinjHubFaultType[];
831 
832 
843 enum EImpinjLocationReportType
844 {
845 
846  ImpinjLocationReportType_Entry = 0,
847  ImpinjLocationReportType_Update = 1,
848  ImpinjLocationReportType_Exit = 2,
849 };
850 
851 extern const SEnumTableEntry
852 g_estImpinjLocationReportType[];
853 
854 
898 enum EImpinjDirectionFieldOfView
899 {
900 
901  ImpinjDirectionFieldOfView_ReaderSelected = 0,
902  ImpinjDirectionFieldOfView_Wide = 1,
903  ImpinjDirectionFieldOfView_Narrow = 2,
904 };
905 
906 extern const SEnumTableEntry
907 g_estImpinjDirectionFieldOfView[];
908 
909 
944 enum EImpinjDirectionRFMode
945 {
946 
947  ImpinjDirectionRFMode_HighSensitivity = 0,
948  ImpinjDirectionRFMode_HighPerformance = 1,
949 };
950 
951 extern const SEnumTableEntry
952 g_estImpinjDirectionRFMode[];
953 
954 
1004 enum EImpinjDirectionDiagnosticReportLevel
1005 {
1006 
1007  ImpinjDirectionDiagnosticReportLevel_Off = 0,
1008  ImpinjDirectionDiagnosticReportLevel_Basic = 1,
1009  ImpinjDirectionDiagnosticReportLevel_Extended = 2,
1010  ImpinjDirectionDiagnosticReportLevel_Debug = 3,
1011 };
1012 
1013 extern const SEnumTableEntry
1014 g_estImpinjDirectionDiagnosticReportLevel[];
1015 
1016 
1055 enum EImpinjDirectionReportType
1056 {
1057 
1058  ImpinjDirectionReportType_Entry = 0,
1059  ImpinjDirectionReportType_Update = 1,
1060  ImpinjDirectionReportType_Exit = 2,
1061 };
1062 
1063 extern const SEnumTableEntry
1064 g_estImpinjDirectionReportType[];
1065 
1066 
1105 enum EImpinjDirectionTagPopulationStatus
1106 {
1107 
1108  ImpinjDirectionTagPopulationStatus_OK = 0,
1109  ImpinjDirectionTagPopulationStatus_UserOverflow = 1,
1110  ImpinjDirectionTagPopulationStatus_SystemOverflow = 2,
1111 };
1112 
1113 extern const SEnumTableEntry
1114 g_estImpinjDirectionTagPopulationStatus[];
1115 
1116 
1126 enum EImpinjIntelligentAntennaMode
1127 {
1128 
1129  ImpinjIntelligentAntennaMode_Disabled = 0,
1130  ImpinjIntelligentAntennaMode_Enabled = 1,
1131 };
1132 
1133 extern const SEnumTableEntry
1134 g_estImpinjIntelligentAntennaMode[];
1135 
1136 
1148 enum EImpinjAntennaPolarizationType
1149 {
1150 
1151  ImpinjAntennaPolarizationType_LinearHorizontal = 0,
1152  ImpinjAntennaPolarizationType_LinearVertical = 1,
1153  ImpinjAntennaPolarizationType_CircularRight = 2,
1154  ImpinjAntennaPolarizationType_CircularLeft = 3,
1155 };
1156 
1157 extern const SEnumTableEntry
1158 g_estImpinjAntennaPolarizationType[];
1159 
1160 
1177 enum EImpinjMarginReadResultType
1178 {
1179 
1180  ImpinjMarginReadResultType_Success = 0,
1181  ImpinjMarginReadResultType_Failure = 1,
1182  ImpinjMarginReadResultType_Insufficient_Power = 2,
1183  ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3,
1184  ImpinjMarginReadResultType_No_Response_From_Tag = 4,
1185  ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5,
1186  ImpinjMarginReadResultType_Incorrect_Password_Error = 6,
1187  ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7,
1188  ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8,
1189 };
1190 
1191 extern const SEnumTableEntry
1192 g_estImpinjMarginReadResultType[];
1193 
1194 
1208 enum EImpinjAuthenticateResultType
1209 {
1210 
1211  ImpinjAuthenticateResultType_Success = 0,
1212  ImpinjAuthenticateResultType_Insufficient_Power = 1,
1213  ImpinjAuthenticateResultType_Not_Supported_Error = 2,
1214  ImpinjAuthenticateResultType_Nonspecific_Tag_Error = 3,
1215  ImpinjAuthenticateResultType_Nonspecific_Reader_Error = 4,
1216  ImpinjAuthenticateResultType_No_Response_From_Tag = 5,
1217 };
1218 
1219 extern const SEnumTableEntry
1220 g_estImpinjAuthenticateResultType[];
1221 
1222 
1228 
1252 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1253 {
1254  public:
1256  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1257 
1260 
1261  static const CFieldDescriptor * const
1262  s_apFieldDescriptorTable[];
1263 
1264  static const CTypeDescriptor
1265  s_typeDescriptor;
1266 
1267  void
1268  decodeFields (
1269  CDecoderStream * pDecoderStream);
1270 
1271  void
1272  assimilateSubParameters (
1273  CErrorDetails * pError);
1274 
1275  void
1276  encode (
1277  CEncoderStream * pEncoderStream) const;
1278 
1279 
1280 
1281  static CElement *
1282  s_construct (void);
1283 
1284  static void
1285  s_decodeFields (
1286  CDecoderStream * pDecoderStream,
1287  CElement * pElement);
1289 
1290 
1291 
1292  protected:
1293  std::list<CParameter *> m_listCustom;
1294 
1295  public:
1297  inline std::list<CParameter *>::iterator
1299  {
1300  return m_listCustom.begin();
1301  }
1302 
1304  inline std::list<CParameter *>::iterator
1305  endCustom (void)
1306  {
1307  return m_listCustom.end();
1308  }
1309 
1311  inline void
1313  {
1314  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1315  }
1316 
1318  inline int
1320  {
1321  return (int) (m_listCustom.size());
1322  }
1323 
1324  EResultCode
1326  addCustom (
1327  CParameter * pValue);
1328 
1329 
1330 };
1331 
1332 
1356 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1357 {
1358  public:
1361 
1364 
1365  static const CFieldDescriptor * const
1366  s_apFieldDescriptorTable[];
1367 
1368  static const CTypeDescriptor
1369  s_typeDescriptor;
1370 
1371  void
1372  decodeFields (
1373  CDecoderStream * pDecoderStream);
1374 
1375  void
1376  assimilateSubParameters (
1377  CErrorDetails * pError);
1378 
1379  void
1380  encode (
1381  CEncoderStream * pEncoderStream) const;
1382 
1383 
1384 
1385  static CElement *
1386  s_construct (void);
1387 
1388  static void
1389  s_decodeFields (
1390  CDecoderStream * pDecoderStream,
1391  CElement * pElement);
1393 
1394 
1395 
1396  protected:
1397  CLLRPStatus * m_pLLRPStatus;
1398 
1399  public:
1401  inline CLLRPStatus *
1403  {
1404  return m_pLLRPStatus;
1405  }
1406 
1408  EResultCode
1409  setLLRPStatus (
1410  CLLRPStatus * pValue);
1411 
1412 
1413  protected:
1414  std::list<CParameter *> m_listCustom;
1415 
1416  public:
1418  inline std::list<CParameter *>::iterator
1420  {
1421  return m_listCustom.begin();
1422  }
1423 
1425  inline std::list<CParameter *>::iterator
1426  endCustom (void)
1427  {
1428  return m_listCustom.end();
1429  }
1430 
1432  inline void
1434  {
1435  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1436  }
1437 
1439  inline int
1441  {
1442  return (int) (m_listCustom.size());
1443  }
1444 
1445  EResultCode
1447  addCustom (
1448  CParameter * pValue);
1449 
1450 
1451 };
1452 
1453 
1487 class CIMPINJ_SAVE_SETTINGS : public CMessage
1488 {
1489  public:
1490  CIMPINJ_SAVE_SETTINGS (void);
1491  ~CIMPINJ_SAVE_SETTINGS (void);
1492 
1495 
1496  static const CFieldDescriptor * const
1497  s_apFieldDescriptorTable[];
1498 
1499  static const CTypeDescriptor
1500  s_typeDescriptor;
1501 
1502  void
1503  decodeFields (
1504  CDecoderStream * pDecoderStream);
1505 
1506  void
1507  assimilateSubParameters (
1508  CErrorDetails * pError);
1509 
1510  void
1511  encode (
1512  CEncoderStream * pEncoderStream) const;
1513 
1514 
1515 
1516  static CElement *
1517  s_construct (void);
1518 
1519  static void
1520  s_decodeFields (
1521  CDecoderStream * pDecoderStream,
1522  CElement * pElement);
1524 
1525 
1526  protected:
1527  llrp_u1_t m_SaveConfiguration;
1528 
1531  public:
1532  static const CFieldDescriptor
1533  s_fdSaveConfiguration;
1535 
1537  inline llrp_u1_t
1539  {
1540  return m_SaveConfiguration;
1541  }
1542 
1544  inline void
1546  llrp_u1_t value)
1547  {
1548  m_SaveConfiguration = value;
1549  }
1550 
1551 
1552 
1553  protected:
1554  std::list<CParameter *> m_listCustom;
1555 
1556  public:
1558  inline std::list<CParameter *>::iterator
1560  {
1561  return m_listCustom.begin();
1562  }
1563 
1565  inline std::list<CParameter *>::iterator
1566  endCustom (void)
1567  {
1568  return m_listCustom.end();
1569  }
1570 
1572  inline void
1574  {
1575  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1576  }
1577 
1579  inline int
1581  {
1582  return (int) (m_listCustom.size());
1583  }
1584 
1585  EResultCode
1587  addCustom (
1588  CParameter * pValue);
1589 
1590 
1591 };
1592 
1593 
1617 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1618 {
1619  public:
1622 
1625 
1626  static const CFieldDescriptor * const
1627  s_apFieldDescriptorTable[];
1628 
1629  static const CTypeDescriptor
1630  s_typeDescriptor;
1631 
1632  void
1633  decodeFields (
1634  CDecoderStream * pDecoderStream);
1635 
1636  void
1637  assimilateSubParameters (
1638  CErrorDetails * pError);
1639 
1640  void
1641  encode (
1642  CEncoderStream * pEncoderStream) const;
1643 
1644 
1645 
1646  static CElement *
1647  s_construct (void);
1648 
1649  static void
1650  s_decodeFields (
1651  CDecoderStream * pDecoderStream,
1652  CElement * pElement);
1654 
1655 
1656 
1657  protected:
1658  CLLRPStatus * m_pLLRPStatus;
1659 
1660  public:
1662  inline CLLRPStatus *
1664  {
1665  return m_pLLRPStatus;
1666  }
1667 
1669  EResultCode
1670  setLLRPStatus (
1671  CLLRPStatus * pValue);
1672 
1673 
1674  protected:
1675  std::list<CParameter *> m_listCustom;
1676 
1677  public:
1679  inline std::list<CParameter *>::iterator
1681  {
1682  return m_listCustom.begin();
1683  }
1684 
1686  inline std::list<CParameter *>::iterator
1687  endCustom (void)
1688  {
1689  return m_listCustom.end();
1690  }
1691 
1693  inline void
1695  {
1696  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1697  }
1698 
1700  inline int
1702  {
1703  return (int) (m_listCustom.size());
1704  }
1705 
1706  EResultCode
1708  addCustom (
1709  CParameter * pValue);
1710 
1711 
1712 };
1713 
1714 
1722 
1745 class CImpinjRequestedData : public CParameter
1746 {
1747  public:
1748  CImpinjRequestedData (void);
1749  ~CImpinjRequestedData (void);
1750 
1753 
1754  static const CFieldDescriptor * const
1755  s_apFieldDescriptorTable[];
1756 
1757  static const CTypeDescriptor
1758  s_typeDescriptor;
1759 
1760  void
1761  decodeFields (
1762  CDecoderStream * pDecoderStream);
1763 
1764  void
1765  assimilateSubParameters (
1766  CErrorDetails * pError);
1767 
1768  void
1769  encode (
1770  CEncoderStream * pEncoderStream) const;
1771 
1772 
1773  llrp_bool_t
1774  isAllowedIn (
1775  const CTypeDescriptor * pEnclosingElementType) const;
1776 
1777 
1778  static CElement *
1779  s_construct (void);
1780 
1781  static void
1782  s_decodeFields (
1783  CDecoderStream * pDecoderStream,
1784  CElement * pElement);
1786 
1787 
1788  protected:
1789  EImpinjRequestedDataType m_eRequestedData;
1790 
1793  public:
1794  static const CFieldDescriptor
1795  s_fdRequestedData;
1797 
1799  inline EImpinjRequestedDataType
1801  {
1802  return m_eRequestedData;
1803  }
1804 
1806  inline void
1808  EImpinjRequestedDataType value)
1809  {
1810  m_eRequestedData = value;
1811  }
1812 
1813 
1814 
1815  protected:
1816  std::list<CParameter *> m_listCustom;
1817 
1818  public:
1820  inline std::list<CParameter *>::iterator
1822  {
1823  return m_listCustom.begin();
1824  }
1825 
1827  inline std::list<CParameter *>::iterator
1828  endCustom (void)
1829  {
1830  return m_listCustom.end();
1831  }
1832 
1834  inline void
1836  {
1837  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1838  }
1839 
1841  inline int
1843  {
1844  return (int) (m_listCustom.size());
1845  }
1846 
1847  EResultCode
1849  addCustom (
1850  CParameter * pValue);
1851 
1852 
1853 };
1854 
1855 
1884 class CImpinjSubRegulatoryRegion : public CParameter
1885 {
1886  public:
1889 
1892 
1893  static const CFieldDescriptor * const
1894  s_apFieldDescriptorTable[];
1895 
1896  static const CTypeDescriptor
1897  s_typeDescriptor;
1898 
1899  void
1900  decodeFields (
1901  CDecoderStream * pDecoderStream);
1902 
1903  void
1904  assimilateSubParameters (
1905  CErrorDetails * pError);
1906 
1907  void
1908  encode (
1909  CEncoderStream * pEncoderStream) const;
1910 
1911 
1912  llrp_bool_t
1913  isAllowedIn (
1914  const CTypeDescriptor * pEnclosingElementType) const;
1915 
1916 
1917  static CElement *
1918  s_construct (void);
1919 
1920  static void
1921  s_decodeFields (
1922  CDecoderStream * pDecoderStream,
1923  CElement * pElement);
1925 
1926 
1927  protected:
1928  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1929 
1932  public:
1933  static const CFieldDescriptor
1934  s_fdRegulatoryRegion;
1936 
1938  inline EImpinjRegulatoryRegion
1940  {
1941  return m_eRegulatoryRegion;
1942  }
1943 
1945  inline void
1947  EImpinjRegulatoryRegion value)
1948  {
1949  m_eRegulatoryRegion = value;
1950  }
1951 
1952 
1953 
1954  protected:
1955  std::list<CParameter *> m_listCustom;
1956 
1957  public:
1959  inline std::list<CParameter *>::iterator
1961  {
1962  return m_listCustom.begin();
1963  }
1964 
1966  inline std::list<CParameter *>::iterator
1967  endCustom (void)
1968  {
1969  return m_listCustom.end();
1970  }
1971 
1973  inline void
1975  {
1976  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1977  }
1978 
1980  inline int
1982  {
1983  return (int) (m_listCustom.size());
1984  }
1985 
1986  EResultCode
1988  addCustom (
1989  CParameter * pValue);
1990 
1991 
1992 };
1993 
1994 
2019 class CImpinjInventorySearchMode : public CParameter
2020 {
2021  public:
2024 
2027 
2028  static const CFieldDescriptor * const
2029  s_apFieldDescriptorTable[];
2030 
2031  static const CTypeDescriptor
2032  s_typeDescriptor;
2033 
2034  void
2035  decodeFields (
2036  CDecoderStream * pDecoderStream);
2037 
2038  void
2039  assimilateSubParameters (
2040  CErrorDetails * pError);
2041 
2042  void
2043  encode (
2044  CEncoderStream * pEncoderStream) const;
2045 
2046 
2047  llrp_bool_t
2048  isAllowedIn (
2049  const CTypeDescriptor * pEnclosingElementType) const;
2050 
2051 
2052  static CElement *
2053  s_construct (void);
2054 
2055  static void
2056  s_decodeFields (
2057  CDecoderStream * pDecoderStream,
2058  CElement * pElement);
2060 
2061 
2062  protected:
2063  EImpinjInventorySearchType m_eInventorySearchMode;
2064 
2067  public:
2068  static const CFieldDescriptor
2069  s_fdInventorySearchMode;
2071 
2073  inline EImpinjInventorySearchType
2075  {
2076  return m_eInventorySearchMode;
2077  }
2078 
2080  inline void
2082  EImpinjInventorySearchType value)
2083  {
2084  m_eInventorySearchMode = value;
2085  }
2086 
2087 
2088 
2089  protected:
2090  std::list<CParameter *> m_listCustom;
2091 
2092  public:
2094  inline std::list<CParameter *>::iterator
2096  {
2097  return m_listCustom.begin();
2098  }
2099 
2101  inline std::list<CParameter *>::iterator
2102  endCustom (void)
2103  {
2104  return m_listCustom.end();
2105  }
2106 
2108  inline void
2110  {
2111  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2112  }
2113 
2115  inline int
2117  {
2118  return (int) (m_listCustom.size());
2119  }
2120 
2121  EResultCode
2123  addCustom (
2124  CParameter * pValue);
2125 
2126 
2127 };
2128 
2129 
2159 class CImpinjFixedFrequencyList : public CParameter
2160 {
2161  public:
2163  ~CImpinjFixedFrequencyList (void);
2164 
2167 
2168  static const CFieldDescriptor * const
2169  s_apFieldDescriptorTable[];
2170 
2171  static const CTypeDescriptor
2172  s_typeDescriptor;
2173 
2174  void
2175  decodeFields (
2176  CDecoderStream * pDecoderStream);
2177 
2178  void
2179  assimilateSubParameters (
2180  CErrorDetails * pError);
2181 
2182  void
2183  encode (
2184  CEncoderStream * pEncoderStream) const;
2185 
2186 
2187  llrp_bool_t
2188  isAllowedIn (
2189  const CTypeDescriptor * pEnclosingElementType) const;
2190 
2191 
2192  static CElement *
2193  s_construct (void);
2194 
2195  static void
2196  s_decodeFields (
2197  CDecoderStream * pDecoderStream,
2198  CElement * pElement);
2200 
2201 
2202  protected:
2203  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
2204 
2207  public:
2208  static const CFieldDescriptor
2209  s_fdFixedFrequencyMode;
2211 
2213  inline EImpinjFixedFrequencyMode
2215  {
2216  return m_eFixedFrequencyMode;
2217  }
2218 
2220  inline void
2222  EImpinjFixedFrequencyMode value)
2223  {
2224  m_eFixedFrequencyMode = value;
2225  }
2226 
2227 
2228  protected:
2229  llrp_u16v_t m_ChannelList;
2230 
2233  public:
2234  static const CFieldDescriptor
2235  s_fdChannelList;
2237 
2239  inline llrp_u16v_t
2241  {
2242  return m_ChannelList;
2243  }
2244 
2246  inline void
2248  llrp_u16v_t value)
2249  {
2250  m_ChannelList = value;
2251  }
2252 
2253 
2254 
2255  protected:
2256  std::list<CParameter *> m_listCustom;
2257 
2258  public:
2260  inline std::list<CParameter *>::iterator
2262  {
2263  return m_listCustom.begin();
2264  }
2265 
2267  inline std::list<CParameter *>::iterator
2268  endCustom (void)
2269  {
2270  return m_listCustom.end();
2271  }
2272 
2274  inline void
2276  {
2277  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2278  }
2279 
2281  inline int
2283  {
2284  return (int) (m_listCustom.size());
2285  }
2286 
2287  EResultCode
2289  addCustom (
2290  CParameter * pValue);
2291 
2292 
2293 };
2294 
2295 
2325 class CImpinjReducedPowerFrequencyList : public CParameter
2326 {
2327  public:
2330 
2333 
2334  static const CFieldDescriptor * const
2335  s_apFieldDescriptorTable[];
2336 
2337  static const CTypeDescriptor
2338  s_typeDescriptor;
2339 
2340  void
2341  decodeFields (
2342  CDecoderStream * pDecoderStream);
2343 
2344  void
2345  assimilateSubParameters (
2346  CErrorDetails * pError);
2347 
2348  void
2349  encode (
2350  CEncoderStream * pEncoderStream) const;
2351 
2352 
2353  llrp_bool_t
2354  isAllowedIn (
2355  const CTypeDescriptor * pEnclosingElementType) const;
2356 
2357 
2358  static CElement *
2359  s_construct (void);
2360 
2361  static void
2362  s_decodeFields (
2363  CDecoderStream * pDecoderStream,
2364  CElement * pElement);
2366 
2367 
2368  protected:
2369  EImpinjReducedPowerMode m_eReducedPowerMode;
2370 
2373  public:
2374  static const CFieldDescriptor
2375  s_fdReducedPowerMode;
2377 
2379  inline EImpinjReducedPowerMode
2381  {
2382  return m_eReducedPowerMode;
2383  }
2384 
2386  inline void
2388  EImpinjReducedPowerMode value)
2389  {
2390  m_eReducedPowerMode = value;
2391  }
2392 
2393 
2394  protected:
2395  llrp_u16v_t m_ChannelList;
2396 
2399  public:
2400  static const CFieldDescriptor
2401  s_fdChannelList;
2403 
2405  inline llrp_u16v_t
2407  {
2408  return m_ChannelList;
2409  }
2410 
2412  inline void
2414  llrp_u16v_t value)
2415  {
2416  m_ChannelList = value;
2417  }
2418 
2419 
2420 
2421  protected:
2422  std::list<CParameter *> m_listCustom;
2423 
2424  public:
2426  inline std::list<CParameter *>::iterator
2428  {
2429  return m_listCustom.begin();
2430  }
2431 
2433  inline std::list<CParameter *>::iterator
2434  endCustom (void)
2435  {
2436  return m_listCustom.end();
2437  }
2438 
2440  inline void
2442  {
2443  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2444  }
2445 
2447  inline int
2449  {
2450  return (int) (m_listCustom.size());
2451  }
2452 
2453  EResultCode
2455  addCustom (
2456  CParameter * pValue);
2457 
2458 
2459 };
2460 
2461 
2491 class CImpinjLowDutyCycle : public CParameter
2492 {
2493  public:
2494  CImpinjLowDutyCycle (void);
2495  ~CImpinjLowDutyCycle (void);
2496 
2499 
2500  static const CFieldDescriptor * const
2501  s_apFieldDescriptorTable[];
2502 
2503  static const CTypeDescriptor
2504  s_typeDescriptor;
2505 
2506  void
2507  decodeFields (
2508  CDecoderStream * pDecoderStream);
2509 
2510  void
2511  assimilateSubParameters (
2512  CErrorDetails * pError);
2513 
2514  void
2515  encode (
2516  CEncoderStream * pEncoderStream) const;
2517 
2518 
2519  llrp_bool_t
2520  isAllowedIn (
2521  const CTypeDescriptor * pEnclosingElementType) const;
2522 
2523 
2524  static CElement *
2525  s_construct (void);
2526 
2527  static void
2528  s_decodeFields (
2529  CDecoderStream * pDecoderStream,
2530  CElement * pElement);
2532 
2533 
2534  protected:
2535  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2536 
2539  public:
2540  static const CFieldDescriptor
2541  s_fdLowDutyCycleMode;
2543 
2545  inline EImpinjLowDutyCycleMode
2547  {
2548  return m_eLowDutyCycleMode;
2549  }
2550 
2552  inline void
2554  EImpinjLowDutyCycleMode value)
2555  {
2556  m_eLowDutyCycleMode = value;
2557  }
2558 
2559 
2560  protected:
2561  llrp_u16_t m_EmptyFieldTimeout;
2562 
2565  public:
2566  static const CFieldDescriptor
2567  s_fdEmptyFieldTimeout;
2569 
2571  inline llrp_u16_t
2573  {
2574  return m_EmptyFieldTimeout;
2575  }
2576 
2578  inline void
2580  llrp_u16_t value)
2581  {
2582  m_EmptyFieldTimeout = value;
2583  }
2584 
2585 
2586  protected:
2587  llrp_u16_t m_FieldPingInterval;
2588 
2591  public:
2592  static const CFieldDescriptor
2593  s_fdFieldPingInterval;
2595 
2597  inline llrp_u16_t
2599  {
2600  return m_FieldPingInterval;
2601  }
2602 
2604  inline void
2606  llrp_u16_t value)
2607  {
2608  m_FieldPingInterval = value;
2609  }
2610 
2611 
2612 
2613  protected:
2614  std::list<CParameter *> m_listCustom;
2615 
2616  public:
2618  inline std::list<CParameter *>::iterator
2620  {
2621  return m_listCustom.begin();
2622  }
2623 
2625  inline std::list<CParameter *>::iterator
2626  endCustom (void)
2627  {
2628  return m_listCustom.end();
2629  }
2630 
2632  inline void
2634  {
2635  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2636  }
2637 
2639  inline int
2641  {
2642  return (int) (m_listCustom.size());
2643  }
2644 
2645  EResultCode
2647  addCustom (
2648  CParameter * pValue);
2649 
2650 
2651 };
2652 
2653 
2678 class CImpinjHubVersions : public CParameter
2679 {
2680  public:
2681  CImpinjHubVersions (void);
2682  ~CImpinjHubVersions (void);
2683 
2686 
2687  static const CFieldDescriptor * const
2688  s_apFieldDescriptorTable[];
2689 
2690  static const CTypeDescriptor
2691  s_typeDescriptor;
2692 
2693  void
2694  decodeFields (
2695  CDecoderStream * pDecoderStream);
2696 
2697  void
2698  assimilateSubParameters (
2699  CErrorDetails * pError);
2700 
2701  void
2702  encode (
2703  CEncoderStream * pEncoderStream) const;
2704 
2705 
2706  llrp_bool_t
2707  isAllowedIn (
2708  const CTypeDescriptor * pEnclosingElementType) const;
2709 
2710 
2711  static CElement *
2712  s_construct (void);
2713 
2714  static void
2715  s_decodeFields (
2716  CDecoderStream * pDecoderStream,
2717  CElement * pElement);
2719 
2720 
2721 
2722  protected:
2723  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2724 
2725  public:
2727  inline std::list<CImpinjArrayVersion *>::iterator
2729  {
2730  return m_listImpinjArrayVersion.begin();
2731  }
2732 
2734  inline std::list<CImpinjArrayVersion *>::iterator
2736  {
2737  return m_listImpinjArrayVersion.end();
2738  }
2739 
2741  inline void
2743  {
2744  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2745  }
2746 
2748  inline int
2750  {
2751  return (int) (m_listImpinjArrayVersion.size());
2752  }
2753 
2754  EResultCode
2756  addImpinjArrayVersion (
2757  CImpinjArrayVersion * pValue);
2758 
2759 
2760  protected:
2761  std::list<CParameter *> m_listCustom;
2762 
2763  public:
2765  inline std::list<CParameter *>::iterator
2767  {
2768  return m_listCustom.begin();
2769  }
2770 
2772  inline std::list<CParameter *>::iterator
2773  endCustom (void)
2774  {
2775  return m_listCustom.end();
2776  }
2777 
2779  inline void
2781  {
2782  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2783  }
2784 
2786  inline int
2788  {
2789  return (int) (m_listCustom.size());
2790  }
2791 
2792  EResultCode
2794  addCustom (
2795  CParameter * pValue);
2796 
2797 
2798 };
2799 
2800 
2833 class CImpinjDetailedVersion : public CParameter
2834 {
2835  public:
2836  CImpinjDetailedVersion (void);
2837  ~CImpinjDetailedVersion (void);
2838 
2841 
2842  static const CFieldDescriptor * const
2843  s_apFieldDescriptorTable[];
2844 
2845  static const CTypeDescriptor
2846  s_typeDescriptor;
2847 
2848  void
2849  decodeFields (
2850  CDecoderStream * pDecoderStream);
2851 
2852  void
2853  assimilateSubParameters (
2854  CErrorDetails * pError);
2855 
2856  void
2857  encode (
2858  CEncoderStream * pEncoderStream) const;
2859 
2860 
2861  llrp_bool_t
2862  isAllowedIn (
2863  const CTypeDescriptor * pEnclosingElementType) const;
2864 
2865 
2866  static CElement *
2867  s_construct (void);
2868 
2869  static void
2870  s_decodeFields (
2871  CDecoderStream * pDecoderStream,
2872  CElement * pElement);
2874 
2875 
2876  protected:
2877  llrp_utf8v_t m_ModelName;
2878 
2881  public:
2882  static const CFieldDescriptor
2883  s_fdModelName;
2885 
2887  inline llrp_utf8v_t
2889  {
2890  return m_ModelName;
2891  }
2892 
2894  inline void
2896  llrp_utf8v_t value)
2897  {
2898  m_ModelName = value;
2899  }
2900 
2901 
2902  protected:
2903  llrp_utf8v_t m_SerialNumber;
2904 
2907  public:
2908  static const CFieldDescriptor
2909  s_fdSerialNumber;
2911 
2913  inline llrp_utf8v_t
2915  {
2916  return m_SerialNumber;
2917  }
2918 
2920  inline void
2922  llrp_utf8v_t value)
2923  {
2924  m_SerialNumber = value;
2925  }
2926 
2927 
2928  protected:
2929  llrp_utf8v_t m_SoftwareVersion;
2930 
2933  public:
2934  static const CFieldDescriptor
2935  s_fdSoftwareVersion;
2937 
2939  inline llrp_utf8v_t
2941  {
2942  return m_SoftwareVersion;
2943  }
2944 
2946  inline void
2948  llrp_utf8v_t value)
2949  {
2950  m_SoftwareVersion = value;
2951  }
2952 
2953 
2954  protected:
2955  llrp_utf8v_t m_FirmwareVersion;
2956 
2959  public:
2960  static const CFieldDescriptor
2961  s_fdFirmwareVersion;
2963 
2965  inline llrp_utf8v_t
2967  {
2968  return m_FirmwareVersion;
2969  }
2970 
2972  inline void
2974  llrp_utf8v_t value)
2975  {
2976  m_FirmwareVersion = value;
2977  }
2978 
2979 
2980  protected:
2981  llrp_utf8v_t m_FPGAVersion;
2982 
2985  public:
2986  static const CFieldDescriptor
2987  s_fdFPGAVersion;
2989 
2991  inline llrp_utf8v_t
2993  {
2994  return m_FPGAVersion;
2995  }
2996 
2998  inline void
3000  llrp_utf8v_t value)
3001  {
3002  m_FPGAVersion = value;
3003  }
3004 
3005 
3006  protected:
3007  llrp_utf8v_t m_PCBAVersion;
3008 
3011  public:
3012  static const CFieldDescriptor
3013  s_fdPCBAVersion;
3015 
3017  inline llrp_utf8v_t
3019  {
3020  return m_PCBAVersion;
3021  }
3022 
3024  inline void
3026  llrp_utf8v_t value)
3027  {
3028  m_PCBAVersion = value;
3029  }
3030 
3031 
3032 
3033  protected:
3034  CImpinjHubVersions * m_pImpinjHubVersions;
3035 
3036  public:
3038  inline CImpinjHubVersions *
3040  {
3041  return m_pImpinjHubVersions;
3042  }
3043 
3045  EResultCode
3046  setImpinjHubVersions (
3047  CImpinjHubVersions * pValue);
3048 
3049 
3050  protected:
3051  CImpinjArrayVersion * m_pImpinjArrayVersion;
3052 
3053  public:
3055  inline CImpinjArrayVersion *
3057  {
3058  return m_pImpinjArrayVersion;
3059  }
3060 
3062  EResultCode
3063  setImpinjArrayVersion (
3064  CImpinjArrayVersion * pValue);
3065 
3066 
3067  protected:
3068  CImpinjBLEVersion * m_pImpinjBLEVersion;
3069 
3070  public:
3072  inline CImpinjBLEVersion *
3074  {
3075  return m_pImpinjBLEVersion;
3076  }
3077 
3079  EResultCode
3080  setImpinjBLEVersion (
3081  CImpinjBLEVersion * pValue);
3082 
3083 
3084  protected:
3085  std::list<CParameter *> m_listCustom;
3086 
3087  public:
3089  inline std::list<CParameter *>::iterator
3091  {
3092  return m_listCustom.begin();
3093  }
3094 
3096  inline std::list<CParameter *>::iterator
3097  endCustom (void)
3098  {
3099  return m_listCustom.end();
3100  }
3101 
3103  inline void
3105  {
3106  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3107  }
3108 
3110  inline int
3112  {
3113  return (int) (m_listCustom.size());
3114  }
3115 
3116  EResultCode
3118  addCustom (
3119  CParameter * pValue);
3120 
3121 
3122 };
3123 
3124 
3149 class CImpinjFrequencyCapabilities : public CParameter
3150 {
3151  public:
3154 
3157 
3158  static const CFieldDescriptor * const
3159  s_apFieldDescriptorTable[];
3160 
3161  static const CTypeDescriptor
3162  s_typeDescriptor;
3163 
3164  void
3165  decodeFields (
3166  CDecoderStream * pDecoderStream);
3167 
3168  void
3169  assimilateSubParameters (
3170  CErrorDetails * pError);
3171 
3172  void
3173  encode (
3174  CEncoderStream * pEncoderStream) const;
3175 
3176 
3177  llrp_bool_t
3178  isAllowedIn (
3179  const CTypeDescriptor * pEnclosingElementType) const;
3180 
3181 
3182  static CElement *
3183  s_construct (void);
3184 
3185  static void
3186  s_decodeFields (
3187  CDecoderStream * pDecoderStream,
3188  CElement * pElement);
3190 
3191 
3192  protected:
3193  llrp_u32v_t m_FrequencyList;
3194 
3197  public:
3198  static const CFieldDescriptor
3199  s_fdFrequencyList;
3201 
3203  inline llrp_u32v_t
3205  {
3206  return m_FrequencyList;
3207  }
3208 
3210  inline void
3212  llrp_u32v_t value)
3213  {
3214  m_FrequencyList = value;
3215  }
3216 
3217 
3218 
3219  protected:
3220  std::list<CParameter *> m_listCustom;
3221 
3222  public:
3224  inline std::list<CParameter *>::iterator
3226  {
3227  return m_listCustom.begin();
3228  }
3229 
3231  inline std::list<CParameter *>::iterator
3232  endCustom (void)
3233  {
3234  return m_listCustom.end();
3235  }
3236 
3238  inline void
3240  {
3241  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3242  }
3243 
3245  inline int
3247  {
3248  return (int) (m_listCustom.size());
3249  }
3250 
3251  EResultCode
3253  addCustom (
3254  CParameter * pValue);
3255 
3256 
3257 };
3258 
3259 
3286 class CImpinjGPIDebounceConfiguration : public CParameter
3287 {
3288  public:
3291 
3294 
3295  static const CFieldDescriptor * const
3296  s_apFieldDescriptorTable[];
3297 
3298  static const CTypeDescriptor
3299  s_typeDescriptor;
3300 
3301  void
3302  decodeFields (
3303  CDecoderStream * pDecoderStream);
3304 
3305  void
3306  assimilateSubParameters (
3307  CErrorDetails * pError);
3308 
3309  void
3310  encode (
3311  CEncoderStream * pEncoderStream) const;
3312 
3313 
3314  llrp_bool_t
3315  isAllowedIn (
3316  const CTypeDescriptor * pEnclosingElementType) const;
3317 
3318 
3319  static CElement *
3320  s_construct (void);
3321 
3322  static void
3323  s_decodeFields (
3324  CDecoderStream * pDecoderStream,
3325  CElement * pElement);
3327 
3328 
3329  protected:
3330  llrp_u16_t m_GPIPortNum;
3331 
3334  public:
3335  static const CFieldDescriptor
3336  s_fdGPIPortNum;
3338 
3340  inline llrp_u16_t
3342  {
3343  return m_GPIPortNum;
3344  }
3345 
3347  inline void
3349  llrp_u16_t value)
3350  {
3351  m_GPIPortNum = value;
3352  }
3353 
3354 
3355  protected:
3356  llrp_u32_t m_GPIDebounceTimerMSec;
3357 
3360  public:
3361  static const CFieldDescriptor
3362  s_fdGPIDebounceTimerMSec;
3364 
3366  inline llrp_u32_t
3368  {
3369  return m_GPIDebounceTimerMSec;
3370  }
3371 
3373  inline void
3375  llrp_u32_t value)
3376  {
3377  m_GPIDebounceTimerMSec = value;
3378  }
3379 
3380 
3381 
3382  protected:
3383  std::list<CParameter *> m_listCustom;
3384 
3385  public:
3387  inline std::list<CParameter *>::iterator
3389  {
3390  return m_listCustom.begin();
3391  }
3392 
3394  inline std::list<CParameter *>::iterator
3395  endCustom (void)
3396  {
3397  return m_listCustom.end();
3398  }
3399 
3401  inline void
3403  {
3404  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3405  }
3406 
3408  inline int
3410  {
3411  return (int) (m_listCustom.size());
3412  }
3413 
3414  EResultCode
3416  addCustom (
3417  CParameter * pValue);
3418 
3419 
3420 };
3421 
3422 
3447 class CImpinjReaderTemperature : public CParameter
3448 {
3449  public:
3450  CImpinjReaderTemperature (void);
3451  ~CImpinjReaderTemperature (void);
3452 
3455 
3456  static const CFieldDescriptor * const
3457  s_apFieldDescriptorTable[];
3458 
3459  static const CTypeDescriptor
3460  s_typeDescriptor;
3461 
3462  void
3463  decodeFields (
3464  CDecoderStream * pDecoderStream);
3465 
3466  void
3467  assimilateSubParameters (
3468  CErrorDetails * pError);
3469 
3470  void
3471  encode (
3472  CEncoderStream * pEncoderStream) const;
3473 
3474 
3475  llrp_bool_t
3476  isAllowedIn (
3477  const CTypeDescriptor * pEnclosingElementType) const;
3478 
3479 
3480  static CElement *
3481  s_construct (void);
3482 
3483  static void
3484  s_decodeFields (
3485  CDecoderStream * pDecoderStream,
3486  CElement * pElement);
3488 
3489 
3490  protected:
3491  llrp_s16_t m_Temperature;
3492 
3495  public:
3496  static const CFieldDescriptor
3497  s_fdTemperature;
3499 
3501  inline llrp_s16_t
3503  {
3504  return m_Temperature;
3505  }
3506 
3508  inline void
3510  llrp_s16_t value)
3511  {
3512  m_Temperature = value;
3513  }
3514 
3515 
3516 
3517  protected:
3518  std::list<CParameter *> m_listCustom;
3519 
3520  public:
3522  inline std::list<CParameter *>::iterator
3524  {
3525  return m_listCustom.begin();
3526  }
3527 
3529  inline std::list<CParameter *>::iterator
3530  endCustom (void)
3531  {
3532  return m_listCustom.end();
3533  }
3534 
3536  inline void
3538  {
3539  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3540  }
3541 
3543  inline int
3545  {
3546  return (int) (m_listCustom.size());
3547  }
3548 
3549  EResultCode
3551  addCustom (
3552  CParameter * pValue);
3553 
3554 
3555 };
3556 
3557 
3584 class CImpinjLinkMonitorConfiguration : public CParameter
3585 {
3586  public:
3589 
3592 
3593  static const CFieldDescriptor * const
3594  s_apFieldDescriptorTable[];
3595 
3596  static const CTypeDescriptor
3597  s_typeDescriptor;
3598 
3599  void
3600  decodeFields (
3601  CDecoderStream * pDecoderStream);
3602 
3603  void
3604  assimilateSubParameters (
3605  CErrorDetails * pError);
3606 
3607  void
3608  encode (
3609  CEncoderStream * pEncoderStream) const;
3610 
3611 
3612  llrp_bool_t
3613  isAllowedIn (
3614  const CTypeDescriptor * pEnclosingElementType) const;
3615 
3616 
3617  static CElement *
3618  s_construct (void);
3619 
3620  static void
3621  s_decodeFields (
3622  CDecoderStream * pDecoderStream,
3623  CElement * pElement);
3625 
3626 
3627  protected:
3628  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3629 
3632  public:
3633  static const CFieldDescriptor
3634  s_fdLinkMonitorMode;
3636 
3638  inline EImpinjLinkMonitorMode
3640  {
3641  return m_eLinkMonitorMode;
3642  }
3643 
3645  inline void
3647  EImpinjLinkMonitorMode value)
3648  {
3649  m_eLinkMonitorMode = value;
3650  }
3651 
3652 
3653  protected:
3654  llrp_u16_t m_LinkDownThreshold;
3655 
3658  public:
3659  static const CFieldDescriptor
3660  s_fdLinkDownThreshold;
3662 
3664  inline llrp_u16_t
3666  {
3667  return m_LinkDownThreshold;
3668  }
3669 
3671  inline void
3673  llrp_u16_t value)
3674  {
3675  m_LinkDownThreshold = value;
3676  }
3677 
3678 
3679 
3680  protected:
3681  std::list<CParameter *> m_listCustom;
3682 
3683  public:
3685  inline std::list<CParameter *>::iterator
3687  {
3688  return m_listCustom.begin();
3689  }
3690 
3692  inline std::list<CParameter *>::iterator
3693  endCustom (void)
3694  {
3695  return m_listCustom.end();
3696  }
3697 
3699  inline void
3701  {
3702  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3703  }
3704 
3706  inline int
3708  {
3709  return (int) (m_listCustom.size());
3710  }
3711 
3712  EResultCode
3714  addCustom (
3715  CParameter * pValue);
3716 
3717 
3718 };
3719 
3720 
3746 class CImpinjReportBufferConfiguration : public CParameter
3747 {
3748  public:
3751 
3754 
3755  static const CFieldDescriptor * const
3756  s_apFieldDescriptorTable[];
3757 
3758  static const CTypeDescriptor
3759  s_typeDescriptor;
3760 
3761  void
3762  decodeFields (
3763  CDecoderStream * pDecoderStream);
3764 
3765  void
3766  assimilateSubParameters (
3767  CErrorDetails * pError);
3768 
3769  void
3770  encode (
3771  CEncoderStream * pEncoderStream) const;
3772 
3773 
3774  llrp_bool_t
3775  isAllowedIn (
3776  const CTypeDescriptor * pEnclosingElementType) const;
3777 
3778 
3779  static CElement *
3780  s_construct (void);
3781 
3782  static void
3783  s_decodeFields (
3784  CDecoderStream * pDecoderStream,
3785  CElement * pElement);
3787 
3788 
3789  protected:
3790  EImpinjReportBufferMode m_eReportBufferMode;
3791 
3794  public:
3795  static const CFieldDescriptor
3796  s_fdReportBufferMode;
3798 
3800  inline EImpinjReportBufferMode
3802  {
3803  return m_eReportBufferMode;
3804  }
3805 
3807  inline void
3809  EImpinjReportBufferMode value)
3810  {
3811  m_eReportBufferMode = value;
3812  }
3813 
3814 
3815 
3816  protected:
3817  std::list<CParameter *> m_listCustom;
3818 
3819  public:
3821  inline std::list<CParameter *>::iterator
3823  {
3824  return m_listCustom.begin();
3825  }
3826 
3828  inline std::list<CParameter *>::iterator
3829  endCustom (void)
3830  {
3831  return m_listCustom.end();
3832  }
3833 
3835  inline void
3837  {
3838  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3839  }
3840 
3842  inline int
3844  {
3845  return (int) (m_listCustom.size());
3846  }
3847 
3848  EResultCode
3850  addCustom (
3851  CParameter * pValue);
3852 
3853 
3854 };
3855 
3856 
3885 class CImpinjAccessSpecConfiguration : public CParameter
3886 {
3887  public:
3890 
3893 
3894  static const CFieldDescriptor * const
3895  s_apFieldDescriptorTable[];
3896 
3897  static const CTypeDescriptor
3898  s_typeDescriptor;
3899 
3900  void
3901  decodeFields (
3902  CDecoderStream * pDecoderStream);
3903 
3904  void
3905  assimilateSubParameters (
3906  CErrorDetails * pError);
3907 
3908  void
3909  encode (
3910  CEncoderStream * pEncoderStream) const;
3911 
3912 
3913  llrp_bool_t
3914  isAllowedIn (
3915  const CTypeDescriptor * pEnclosingElementType) const;
3916 
3917 
3918  static CElement *
3919  s_construct (void);
3920 
3921  static void
3922  s_decodeFields (
3923  CDecoderStream * pDecoderStream,
3924  CElement * pElement);
3926 
3927 
3928 
3929  protected:
3930  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3931 
3932  public:
3936  {
3937  return m_pImpinjBlockWriteWordCount;
3938  }
3939 
3941  EResultCode
3942  setImpinjBlockWriteWordCount (
3943  CImpinjBlockWriteWordCount * pValue);
3944 
3945 
3946  protected:
3947  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3948 
3949  public:
3951  inline CImpinjOpSpecRetryCount *
3953  {
3954  return m_pImpinjOpSpecRetryCount;
3955  }
3956 
3958  EResultCode
3959  setImpinjOpSpecRetryCount (
3960  CImpinjOpSpecRetryCount * pValue);
3961 
3962 
3963  protected:
3964  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3965 
3966  public:
3968  inline CImpinjAccessSpecOrdering *
3970  {
3971  return m_pImpinjAccessSpecOrdering;
3972  }
3973 
3975  EResultCode
3976  setImpinjAccessSpecOrdering (
3977  CImpinjAccessSpecOrdering * pValue);
3978 
3979 
3980  protected:
3981  std::list<CParameter *> m_listCustom;
3982 
3983  public:
3985  inline std::list<CParameter *>::iterator
3987  {
3988  return m_listCustom.begin();
3989  }
3990 
3992  inline std::list<CParameter *>::iterator
3993  endCustom (void)
3994  {
3995  return m_listCustom.end();
3996  }
3997 
3999  inline void
4001  {
4002  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4003  }
4004 
4006  inline int
4008  {
4009  return (int) (m_listCustom.size());
4010  }
4011 
4012  EResultCode
4014  addCustom (
4015  CParameter * pValue);
4016 
4017 
4018 };
4019 
4020 
4044 class CImpinjBlockWriteWordCount : public CParameter
4045 {
4046  public:
4049 
4052 
4053  static const CFieldDescriptor * const
4054  s_apFieldDescriptorTable[];
4055 
4056  static const CTypeDescriptor
4057  s_typeDescriptor;
4058 
4059  void
4060  decodeFields (
4061  CDecoderStream * pDecoderStream);
4062 
4063  void
4064  assimilateSubParameters (
4065  CErrorDetails * pError);
4066 
4067  void
4068  encode (
4069  CEncoderStream * pEncoderStream) const;
4070 
4071 
4072  llrp_bool_t
4073  isAllowedIn (
4074  const CTypeDescriptor * pEnclosingElementType) const;
4075 
4076 
4077  static CElement *
4078  s_construct (void);
4079 
4080  static void
4081  s_decodeFields (
4082  CDecoderStream * pDecoderStream,
4083  CElement * pElement);
4085 
4086 
4087  protected:
4088  llrp_u16_t m_WordCount;
4089 
4092  public:
4093  static const CFieldDescriptor
4094  s_fdWordCount;
4096 
4098  inline llrp_u16_t
4100  {
4101  return m_WordCount;
4102  }
4103 
4105  inline void
4107  llrp_u16_t value)
4108  {
4109  m_WordCount = value;
4110  }
4111 
4112 
4113 
4114  protected:
4115  std::list<CParameter *> m_listCustom;
4116 
4117  public:
4119  inline std::list<CParameter *>::iterator
4121  {
4122  return m_listCustom.begin();
4123  }
4124 
4126  inline std::list<CParameter *>::iterator
4127  endCustom (void)
4128  {
4129  return m_listCustom.end();
4130  }
4131 
4133  inline void
4135  {
4136  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4137  }
4138 
4140  inline int
4142  {
4143  return (int) (m_listCustom.size());
4144  }
4145 
4146  EResultCode
4148  addCustom (
4149  CParameter * pValue);
4150 
4151 
4152 };
4153 
4154 
4184 class CImpinjBlockPermalock : public CParameter
4185 {
4186  public:
4187  CImpinjBlockPermalock (void);
4188  ~CImpinjBlockPermalock (void);
4189 
4192 
4193  static const CFieldDescriptor * const
4194  s_apFieldDescriptorTable[];
4195 
4196  static const CTypeDescriptor
4197  s_typeDescriptor;
4198 
4199  void
4200  decodeFields (
4201  CDecoderStream * pDecoderStream);
4202 
4203  void
4204  assimilateSubParameters (
4205  CErrorDetails * pError);
4206 
4207  void
4208  encode (
4209  CEncoderStream * pEncoderStream) const;
4210 
4211 
4212  llrp_bool_t
4213  isAllowedIn (
4214  const CTypeDescriptor * pEnclosingElementType) const;
4215 
4216 
4217  static CElement *
4218  s_construct (void);
4219 
4220  static void
4221  s_decodeFields (
4222  CDecoderStream * pDecoderStream,
4223  CElement * pElement);
4225 
4226 
4227  protected:
4228  llrp_u16_t m_OpSpecID;
4229 
4232  public:
4233  static const CFieldDescriptor
4234  s_fdOpSpecID;
4236 
4238  inline llrp_u16_t
4240  {
4241  return m_OpSpecID;
4242  }
4243 
4245  inline void
4247  llrp_u16_t value)
4248  {
4249  m_OpSpecID = value;
4250  }
4251 
4252 
4253  protected:
4254  llrp_u32_t m_AccessPassword;
4255 
4258  public:
4259  static const CFieldDescriptor
4260  s_fdAccessPassword;
4262 
4264  inline llrp_u32_t
4266  {
4267  return m_AccessPassword;
4268  }
4269 
4271  inline void
4273  llrp_u32_t value)
4274  {
4275  m_AccessPassword = value;
4276  }
4277 
4278 
4279  protected:
4280  llrp_u2_t m_MB;
4281 
4284  public:
4285  static const CFieldDescriptor
4286  s_fdMB;
4288 
4290  inline llrp_u2_t
4291  getMB (void)
4292  {
4293  return m_MB;
4294  }
4295 
4297  inline void
4299  llrp_u2_t value)
4300  {
4301  m_MB = value;
4302  }
4303 
4304 
4305  protected:
4306  llrp_u16_t m_BlockPointer;
4307 
4310  public:
4311  static const CFieldDescriptor
4312  s_fdBlockPointer;
4314 
4316  inline llrp_u16_t
4318  {
4319  return m_BlockPointer;
4320  }
4321 
4323  inline void
4325  llrp_u16_t value)
4326  {
4327  m_BlockPointer = value;
4328  }
4329 
4330 
4331  protected:
4332  llrp_u16v_t m_BlockMask;
4333 
4336  public:
4337  static const CFieldDescriptor
4338  s_fdBlockMask;
4340 
4342  inline llrp_u16v_t
4344  {
4345  return m_BlockMask;
4346  }
4347 
4349  inline void
4351  llrp_u16v_t value)
4352  {
4353  m_BlockMask = value;
4354  }
4355 
4356 
4357 
4358  protected:
4359  std::list<CParameter *> m_listCustom;
4360 
4361  public:
4363  inline std::list<CParameter *>::iterator
4365  {
4366  return m_listCustom.begin();
4367  }
4368 
4370  inline std::list<CParameter *>::iterator
4371  endCustom (void)
4372  {
4373  return m_listCustom.end();
4374  }
4375 
4377  inline void
4379  {
4380  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4381  }
4382 
4384  inline int
4386  {
4387  return (int) (m_listCustom.size());
4388  }
4389 
4390  EResultCode
4392  addCustom (
4393  CParameter * pValue);
4394 
4395 
4396 };
4397 
4398 
4424 class CImpinjBlockPermalockOpSpecResult : public CParameter
4425 {
4426  public:
4429 
4432 
4433  static const CFieldDescriptor * const
4434  s_apFieldDescriptorTable[];
4435 
4436  static const CTypeDescriptor
4437  s_typeDescriptor;
4438 
4439  void
4440  decodeFields (
4441  CDecoderStream * pDecoderStream);
4442 
4443  void
4444  assimilateSubParameters (
4445  CErrorDetails * pError);
4446 
4447  void
4448  encode (
4449  CEncoderStream * pEncoderStream) const;
4450 
4451 
4452  llrp_bool_t
4453  isAllowedIn (
4454  const CTypeDescriptor * pEnclosingElementType) const;
4455 
4456 
4457  static CElement *
4458  s_construct (void);
4459 
4460  static void
4461  s_decodeFields (
4462  CDecoderStream * pDecoderStream,
4463  CElement * pElement);
4465 
4466 
4467  protected:
4468  EImpinjBlockPermalockResultType m_eResult;
4469 
4472  public:
4473  static const CFieldDescriptor
4474  s_fdResult;
4476 
4478  inline EImpinjBlockPermalockResultType
4479  getResult (void)
4480  {
4481  return m_eResult;
4482  }
4483 
4485  inline void
4487  EImpinjBlockPermalockResultType value)
4488  {
4489  m_eResult = value;
4490  }
4491 
4492 
4493  protected:
4494  llrp_u16_t m_OpSpecID;
4495 
4498  public:
4499  static const CFieldDescriptor
4500  s_fdOpSpecID;
4502 
4504  inline llrp_u16_t
4506  {
4507  return m_OpSpecID;
4508  }
4509 
4511  inline void
4513  llrp_u16_t value)
4514  {
4515  m_OpSpecID = value;
4516  }
4517 
4518 
4519 
4520  protected:
4521  std::list<CParameter *> m_listCustom;
4522 
4523  public:
4525  inline std::list<CParameter *>::iterator
4527  {
4528  return m_listCustom.begin();
4529  }
4530 
4532  inline std::list<CParameter *>::iterator
4533  endCustom (void)
4534  {
4535  return m_listCustom.end();
4536  }
4537 
4539  inline void
4541  {
4542  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4543  }
4544 
4546  inline int
4548  {
4549  return (int) (m_listCustom.size());
4550  }
4551 
4552  EResultCode
4554  addCustom (
4555  CParameter * pValue);
4556 
4557 
4558 };
4559 
4560 
4590 class CImpinjGetBlockPermalockStatus : public CParameter
4591 {
4592  public:
4595 
4598 
4599  static const CFieldDescriptor * const
4600  s_apFieldDescriptorTable[];
4601 
4602  static const CTypeDescriptor
4603  s_typeDescriptor;
4604 
4605  void
4606  decodeFields (
4607  CDecoderStream * pDecoderStream);
4608 
4609  void
4610  assimilateSubParameters (
4611  CErrorDetails * pError);
4612 
4613  void
4614  encode (
4615  CEncoderStream * pEncoderStream) const;
4616 
4617 
4618  llrp_bool_t
4619  isAllowedIn (
4620  const CTypeDescriptor * pEnclosingElementType) const;
4621 
4622 
4623  static CElement *
4624  s_construct (void);
4625 
4626  static void
4627  s_decodeFields (
4628  CDecoderStream * pDecoderStream,
4629  CElement * pElement);
4631 
4632 
4633  protected:
4634  llrp_u16_t m_OpSpecID;
4635 
4638  public:
4639  static const CFieldDescriptor
4640  s_fdOpSpecID;
4642 
4644  inline llrp_u16_t
4646  {
4647  return m_OpSpecID;
4648  }
4649 
4651  inline void
4653  llrp_u16_t value)
4654  {
4655  m_OpSpecID = value;
4656  }
4657 
4658 
4659  protected:
4660  llrp_u32_t m_AccessPassword;
4661 
4664  public:
4665  static const CFieldDescriptor
4666  s_fdAccessPassword;
4668 
4670  inline llrp_u32_t
4672  {
4673  return m_AccessPassword;
4674  }
4675 
4677  inline void
4679  llrp_u32_t value)
4680  {
4681  m_AccessPassword = value;
4682  }
4683 
4684 
4685  protected:
4686  llrp_u2_t m_MB;
4687 
4690  public:
4691  static const CFieldDescriptor
4692  s_fdMB;
4694 
4696  inline llrp_u2_t
4697  getMB (void)
4698  {
4699  return m_MB;
4700  }
4701 
4703  inline void
4705  llrp_u2_t value)
4706  {
4707  m_MB = value;
4708  }
4709 
4710 
4711  protected:
4712  llrp_u16_t m_BlockPointer;
4713 
4716  public:
4717  static const CFieldDescriptor
4718  s_fdBlockPointer;
4720 
4722  inline llrp_u16_t
4724  {
4725  return m_BlockPointer;
4726  }
4727 
4729  inline void
4731  llrp_u16_t value)
4732  {
4733  m_BlockPointer = value;
4734  }
4735 
4736 
4737  protected:
4738  llrp_u16_t m_BlockRange;
4739 
4742  public:
4743  static const CFieldDescriptor
4744  s_fdBlockRange;
4746 
4748  inline llrp_u16_t
4750  {
4751  return m_BlockRange;
4752  }
4753 
4755  inline void
4757  llrp_u16_t value)
4758  {
4759  m_BlockRange = value;
4760  }
4761 
4762 
4763 
4764  protected:
4765  std::list<CParameter *> m_listCustom;
4766 
4767  public:
4769  inline std::list<CParameter *>::iterator
4771  {
4772  return m_listCustom.begin();
4773  }
4774 
4776  inline std::list<CParameter *>::iterator
4777  endCustom (void)
4778  {
4779  return m_listCustom.end();
4780  }
4781 
4783  inline void
4785  {
4786  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4787  }
4788 
4790  inline int
4792  {
4793  return (int) (m_listCustom.size());
4794  }
4795 
4796  EResultCode
4798  addCustom (
4799  CParameter * pValue);
4800 
4801 
4802 };
4803 
4804 
4831 class CImpinjGetBlockPermalockStatusOpSpecResult : public CParameter
4832 {
4833  public:
4836 
4839 
4840  static const CFieldDescriptor * const
4841  s_apFieldDescriptorTable[];
4842 
4843  static const CTypeDescriptor
4844  s_typeDescriptor;
4845 
4846  void
4847  decodeFields (
4848  CDecoderStream * pDecoderStream);
4849 
4850  void
4851  assimilateSubParameters (
4852  CErrorDetails * pError);
4853 
4854  void
4855  encode (
4856  CEncoderStream * pEncoderStream) const;
4857 
4858 
4859  llrp_bool_t
4860  isAllowedIn (
4861  const CTypeDescriptor * pEnclosingElementType) const;
4862 
4863 
4864  static CElement *
4865  s_construct (void);
4866 
4867  static void
4868  s_decodeFields (
4869  CDecoderStream * pDecoderStream,
4870  CElement * pElement);
4872 
4873 
4874  protected:
4875  EImpinjGetBlockPermalockStatusResultType m_eResult;
4876 
4879  public:
4880  static const CFieldDescriptor
4881  s_fdResult;
4883 
4885  inline EImpinjGetBlockPermalockStatusResultType
4886  getResult (void)
4887  {
4888  return m_eResult;
4889  }
4890 
4892  inline void
4894  EImpinjGetBlockPermalockStatusResultType value)
4895  {
4896  m_eResult = value;
4897  }
4898 
4899 
4900  protected:
4901  llrp_u16_t m_OpSpecID;
4902 
4905  public:
4906  static const CFieldDescriptor
4907  s_fdOpSpecID;
4909 
4911  inline llrp_u16_t
4913  {
4914  return m_OpSpecID;
4915  }
4916 
4918  inline void
4920  llrp_u16_t value)
4921  {
4922  m_OpSpecID = value;
4923  }
4924 
4925 
4926  protected:
4927  llrp_u16v_t m_PermalockStatus;
4928 
4931  public:
4932  static const CFieldDescriptor
4933  s_fdPermalockStatus;
4935 
4937  inline llrp_u16v_t
4939  {
4940  return m_PermalockStatus;
4941  }
4942 
4944  inline void
4946  llrp_u16v_t value)
4947  {
4948  m_PermalockStatus = value;
4949  }
4950 
4951 
4952 
4953  protected:
4954  std::list<CParameter *> m_listCustom;
4955 
4956  public:
4958  inline std::list<CParameter *>::iterator
4960  {
4961  return m_listCustom.begin();
4962  }
4963 
4965  inline std::list<CParameter *>::iterator
4966  endCustom (void)
4967  {
4968  return m_listCustom.end();
4969  }
4970 
4972  inline void
4974  {
4975  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4976  }
4977 
4979  inline int
4981  {
4982  return (int) (m_listCustom.size());
4983  }
4984 
4985  EResultCode
4987  addCustom (
4988  CParameter * pValue);
4989 
4990 
4991 };
4992 
4993 
5023 class CImpinjSetQTConfig : public CParameter
5024 {
5025  public:
5026  CImpinjSetQTConfig (void);
5027  ~CImpinjSetQTConfig (void);
5028 
5031 
5032  static const CFieldDescriptor * const
5033  s_apFieldDescriptorTable[];
5034 
5035  static const CTypeDescriptor
5036  s_typeDescriptor;
5037 
5038  void
5039  decodeFields (
5040  CDecoderStream * pDecoderStream);
5041 
5042  void
5043  assimilateSubParameters (
5044  CErrorDetails * pError);
5045 
5046  void
5047  encode (
5048  CEncoderStream * pEncoderStream) const;
5049 
5050 
5051  llrp_bool_t
5052  isAllowedIn (
5053  const CTypeDescriptor * pEnclosingElementType) const;
5054 
5055 
5056  static CElement *
5057  s_construct (void);
5058 
5059  static void
5060  s_decodeFields (
5061  CDecoderStream * pDecoderStream,
5062  CElement * pElement);
5064 
5065 
5066  protected:
5067  llrp_u16_t m_OpSpecID;
5068 
5071  public:
5072  static const CFieldDescriptor
5073  s_fdOpSpecID;
5075 
5077  inline llrp_u16_t
5079  {
5080  return m_OpSpecID;
5081  }
5082 
5084  inline void
5086  llrp_u16_t value)
5087  {
5088  m_OpSpecID = value;
5089  }
5090 
5091 
5092  protected:
5093  llrp_u32_t m_AccessPassword;
5094 
5097  public:
5098  static const CFieldDescriptor
5099  s_fdAccessPassword;
5101 
5103  inline llrp_u32_t
5105  {
5106  return m_AccessPassword;
5107  }
5108 
5110  inline void
5112  llrp_u32_t value)
5113  {
5114  m_AccessPassword = value;
5115  }
5116 
5117 
5118  protected:
5119  EImpinjQTDataProfile m_eDataProfile;
5120 
5123  public:
5124  static const CFieldDescriptor
5125  s_fdDataProfile;
5127 
5129  inline EImpinjQTDataProfile
5131  {
5132  return m_eDataProfile;
5133  }
5134 
5136  inline void
5138  EImpinjQTDataProfile value)
5139  {
5140  m_eDataProfile = value;
5141  }
5142 
5143 
5144  protected:
5145  EImpinjQTAccessRange m_eAccessRange;
5146 
5149  public:
5150  static const CFieldDescriptor
5151  s_fdAccessRange;
5153 
5155  inline EImpinjQTAccessRange
5157  {
5158  return m_eAccessRange;
5159  }
5160 
5162  inline void
5164  EImpinjQTAccessRange value)
5165  {
5166  m_eAccessRange = value;
5167  }
5168 
5169 
5170  protected:
5171  EImpinjQTPersistence m_ePersistence;
5172 
5175  public:
5176  static const CFieldDescriptor
5177  s_fdPersistence;
5179 
5181  inline EImpinjQTPersistence
5183  {
5184  return m_ePersistence;
5185  }
5186 
5188  inline void
5190  EImpinjQTPersistence value)
5191  {
5192  m_ePersistence = value;
5193  }
5194 
5195 
5196 
5197  protected:
5198  std::list<CParameter *> m_listCustom;
5199 
5200  public:
5202  inline std::list<CParameter *>::iterator
5204  {
5205  return m_listCustom.begin();
5206  }
5207 
5209  inline std::list<CParameter *>::iterator
5210  endCustom (void)
5211  {
5212  return m_listCustom.end();
5213  }
5214 
5216  inline void
5218  {
5219  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5220  }
5221 
5223  inline int
5225  {
5226  return (int) (m_listCustom.size());
5227  }
5228 
5229  EResultCode
5231  addCustom (
5232  CParameter * pValue);
5233 
5234 
5235 };
5236 
5237 
5263 class CImpinjSetQTConfigOpSpecResult : public CParameter
5264 {
5265  public:
5268 
5271 
5272  static const CFieldDescriptor * const
5273  s_apFieldDescriptorTable[];
5274 
5275  static const CTypeDescriptor
5276  s_typeDescriptor;
5277 
5278  void
5279  decodeFields (
5280  CDecoderStream * pDecoderStream);
5281 
5282  void
5283  assimilateSubParameters (
5284  CErrorDetails * pError);
5285 
5286  void
5287  encode (
5288  CEncoderStream * pEncoderStream) const;
5289 
5290 
5291  llrp_bool_t
5292  isAllowedIn (
5293  const CTypeDescriptor * pEnclosingElementType) const;
5294 
5295 
5296  static CElement *
5297  s_construct (void);
5298 
5299  static void
5300  s_decodeFields (
5301  CDecoderStream * pDecoderStream,
5302  CElement * pElement);
5304 
5305 
5306  protected:
5307  EImpinjSetQTConfigResultType m_eResult;
5308 
5311  public:
5312  static const CFieldDescriptor
5313  s_fdResult;
5315 
5317  inline EImpinjSetQTConfigResultType
5318  getResult (void)
5319  {
5320  return m_eResult;
5321  }
5322 
5324  inline void
5326  EImpinjSetQTConfigResultType value)
5327  {
5328  m_eResult = value;
5329  }
5330 
5331 
5332  protected:
5333  llrp_u16_t m_OpSpecID;
5334 
5337  public:
5338  static const CFieldDescriptor
5339  s_fdOpSpecID;
5341 
5343  inline llrp_u16_t
5345  {
5346  return m_OpSpecID;
5347  }
5348 
5350  inline void
5352  llrp_u16_t value)
5353  {
5354  m_OpSpecID = value;
5355  }
5356 
5357 
5358 
5359  protected:
5360  std::list<CParameter *> m_listCustom;
5361 
5362  public:
5364  inline std::list<CParameter *>::iterator
5366  {
5367  return m_listCustom.begin();
5368  }
5369 
5371  inline std::list<CParameter *>::iterator
5372  endCustom (void)
5373  {
5374  return m_listCustom.end();
5375  }
5376 
5378  inline void
5380  {
5381  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5382  }
5383 
5385  inline int
5387  {
5388  return (int) (m_listCustom.size());
5389  }
5390 
5391  EResultCode
5393  addCustom (
5394  CParameter * pValue);
5395 
5396 
5397 };
5398 
5399 
5425 class CImpinjGetQTConfig : public CParameter
5426 {
5427  public:
5428  CImpinjGetQTConfig (void);
5429  ~CImpinjGetQTConfig (void);
5430 
5433 
5434  static const CFieldDescriptor * const
5435  s_apFieldDescriptorTable[];
5436 
5437  static const CTypeDescriptor
5438  s_typeDescriptor;
5439 
5440  void
5441  decodeFields (
5442  CDecoderStream * pDecoderStream);
5443 
5444  void
5445  assimilateSubParameters (
5446  CErrorDetails * pError);
5447 
5448  void
5449  encode (
5450  CEncoderStream * pEncoderStream) const;
5451 
5452 
5453  llrp_bool_t
5454  isAllowedIn (
5455  const CTypeDescriptor * pEnclosingElementType) const;
5456 
5457 
5458  static CElement *
5459  s_construct (void);
5460 
5461  static void
5462  s_decodeFields (
5463  CDecoderStream * pDecoderStream,
5464  CElement * pElement);
5466 
5467 
5468  protected:
5469  llrp_u16_t m_OpSpecID;
5470 
5473  public:
5474  static const CFieldDescriptor
5475  s_fdOpSpecID;
5477 
5479  inline llrp_u16_t
5481  {
5482  return m_OpSpecID;
5483  }
5484 
5486  inline void
5488  llrp_u16_t value)
5489  {
5490  m_OpSpecID = value;
5491  }
5492 
5493 
5494  protected:
5495  llrp_u32_t m_AccessPassword;
5496 
5499  public:
5500  static const CFieldDescriptor
5501  s_fdAccessPassword;
5503 
5505  inline llrp_u32_t
5507  {
5508  return m_AccessPassword;
5509  }
5510 
5512  inline void
5514  llrp_u32_t value)
5515  {
5516  m_AccessPassword = value;
5517  }
5518 
5519 
5520 
5521  protected:
5522  std::list<CParameter *> m_listCustom;
5523 
5524  public:
5526  inline std::list<CParameter *>::iterator
5528  {
5529  return m_listCustom.begin();
5530  }
5531 
5533  inline std::list<CParameter *>::iterator
5534  endCustom (void)
5535  {
5536  return m_listCustom.end();
5537  }
5538 
5540  inline void
5542  {
5543  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5544  }
5545 
5547  inline int
5549  {
5550  return (int) (m_listCustom.size());
5551  }
5552 
5553  EResultCode
5555  addCustom (
5556  CParameter * pValue);
5557 
5558 
5559 };
5560 
5561 
5590 class CImpinjGetQTConfigOpSpecResult : public CParameter
5591 {
5592  public:
5595 
5598 
5599  static const CFieldDescriptor * const
5600  s_apFieldDescriptorTable[];
5601 
5602  static const CTypeDescriptor
5603  s_typeDescriptor;
5604 
5605  void
5606  decodeFields (
5607  CDecoderStream * pDecoderStream);
5608 
5609  void
5610  assimilateSubParameters (
5611  CErrorDetails * pError);
5612 
5613  void
5614  encode (
5615  CEncoderStream * pEncoderStream) const;
5616 
5617 
5618  llrp_bool_t
5619  isAllowedIn (
5620  const CTypeDescriptor * pEnclosingElementType) const;
5621 
5622 
5623  static CElement *
5624  s_construct (void);
5625 
5626  static void
5627  s_decodeFields (
5628  CDecoderStream * pDecoderStream,
5629  CElement * pElement);
5631 
5632 
5633  protected:
5634  EImpinjGetQTConfigResultType m_eResult;
5635 
5638  public:
5639  static const CFieldDescriptor
5640  s_fdResult;
5642 
5644  inline EImpinjGetQTConfigResultType
5645  getResult (void)
5646  {
5647  return m_eResult;
5648  }
5649 
5651  inline void
5653  EImpinjGetQTConfigResultType value)
5654  {
5655  m_eResult = value;
5656  }
5657 
5658 
5659  protected:
5660  llrp_u16_t m_OpSpecID;
5661 
5664  public:
5665  static const CFieldDescriptor
5666  s_fdOpSpecID;
5668 
5670  inline llrp_u16_t
5672  {
5673  return m_OpSpecID;
5674  }
5675 
5677  inline void
5679  llrp_u16_t value)
5680  {
5681  m_OpSpecID = value;
5682  }
5683 
5684 
5685  protected:
5686  EImpinjQTDataProfile m_eDataProfile;
5687 
5690  public:
5691  static const CFieldDescriptor
5692  s_fdDataProfile;
5694 
5696  inline EImpinjQTDataProfile
5698  {
5699  return m_eDataProfile;
5700  }
5701 
5703  inline void
5705  EImpinjQTDataProfile value)
5706  {
5707  m_eDataProfile = value;
5708  }
5709 
5710 
5711  protected:
5712  EImpinjQTAccessRange m_eAccessRange;
5713 
5716  public:
5717  static const CFieldDescriptor
5718  s_fdAccessRange;
5720 
5722  inline EImpinjQTAccessRange
5724  {
5725  return m_eAccessRange;
5726  }
5727 
5729  inline void
5731  EImpinjQTAccessRange value)
5732  {
5733  m_eAccessRange = value;
5734  }
5735 
5736 
5737 
5738  protected:
5739  std::list<CParameter *> m_listCustom;
5740 
5741  public:
5743  inline std::list<CParameter *>::iterator
5745  {
5746  return m_listCustom.begin();
5747  }
5748 
5750  inline std::list<CParameter *>::iterator
5751  endCustom (void)
5752  {
5753  return m_listCustom.end();
5754  }
5755 
5757  inline void
5759  {
5760  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5761  }
5762 
5764  inline int
5766  {
5767  return (int) (m_listCustom.size());
5768  }
5769 
5770  EResultCode
5772  addCustom (
5773  CParameter * pValue);
5774 
5775 
5776 };
5777 
5778 
5809 class CImpinjTagReportContentSelector : public CParameter
5810 {
5811  public:
5814 
5817 
5818  static const CFieldDescriptor * const
5819  s_apFieldDescriptorTable[];
5820 
5821  static const CTypeDescriptor
5822  s_typeDescriptor;
5823 
5824  void
5825  decodeFields (
5826  CDecoderStream * pDecoderStream);
5827 
5828  void
5829  assimilateSubParameters (
5830  CErrorDetails * pError);
5831 
5832  void
5833  encode (
5834  CEncoderStream * pEncoderStream) const;
5835 
5836 
5837  llrp_bool_t
5838  isAllowedIn (
5839  const CTypeDescriptor * pEnclosingElementType) const;
5840 
5841 
5842  static CElement *
5843  s_construct (void);
5844 
5845  static void
5846  s_decodeFields (
5847  CDecoderStream * pDecoderStream,
5848  CElement * pElement);
5850 
5851 
5852 
5853  protected:
5854  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5855 
5856  public:
5860  {
5861  return m_pImpinjEnableSerializedTID;
5862  }
5863 
5865  EResultCode
5866  setImpinjEnableSerializedTID (
5867  CImpinjEnableSerializedTID * pValue);
5868 
5869 
5870  protected:
5871  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5872 
5873  public:
5875  inline CImpinjEnableRFPhaseAngle *
5877  {
5878  return m_pImpinjEnableRFPhaseAngle;
5879  }
5880 
5882  EResultCode
5883  setImpinjEnableRFPhaseAngle (
5884  CImpinjEnableRFPhaseAngle * pValue);
5885 
5886 
5887  protected:
5888  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5889 
5890  public:
5892  inline CImpinjEnablePeakRSSI *
5894  {
5895  return m_pImpinjEnablePeakRSSI;
5896  }
5897 
5899  EResultCode
5900  setImpinjEnablePeakRSSI (
5901  CImpinjEnablePeakRSSI * pValue);
5902 
5903 
5904  protected:
5905  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5906 
5907  public:
5911  {
5912  return m_pImpinjEnableGPSCoordinates;
5913  }
5914 
5916  EResultCode
5917  setImpinjEnableGPSCoordinates (
5918  CImpinjEnableGPSCoordinates * pValue);
5919 
5920 
5921  protected:
5922  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5923 
5924  public:
5928  {
5929  return m_pImpinjEnableOptimizedRead;
5930  }
5931 
5933  EResultCode
5934  setImpinjEnableOptimizedRead (
5935  CImpinjEnableOptimizedRead * pValue);
5936 
5937 
5938  protected:
5939  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5940 
5941  public:
5945  {
5946  return m_pImpinjEnableRFDopplerFrequency;
5947  }
5948 
5950  EResultCode
5951  setImpinjEnableRFDopplerFrequency (
5953 
5954 
5955  protected:
5956  CImpinjEnableTxPower * m_pImpinjEnableTxPower;
5957 
5958  public:
5960  inline CImpinjEnableTxPower *
5962  {
5963  return m_pImpinjEnableTxPower;
5964  }
5965 
5967  EResultCode
5968  setImpinjEnableTxPower (
5969  CImpinjEnableTxPower * pValue);
5970 
5971 
5972  protected:
5973  std::list<CParameter *> m_listCustom;
5974 
5975  public:
5977  inline std::list<CParameter *>::iterator
5979  {
5980  return m_listCustom.begin();
5981  }
5982 
5984  inline std::list<CParameter *>::iterator
5985  endCustom (void)
5986  {
5987  return m_listCustom.end();
5988  }
5989 
5991  inline void
5993  {
5994  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5995  }
5996 
5998  inline int
6000  {
6001  return (int) (m_listCustom.size());
6002  }
6003 
6004  EResultCode
6006  addCustom (
6007  CParameter * pValue);
6008 
6009 
6010 };
6011 
6012 
6036 class CImpinjEnableSerializedTID : public CParameter
6037 {
6038  public:
6041 
6044 
6045  static const CFieldDescriptor * const
6046  s_apFieldDescriptorTable[];
6047 
6048  static const CTypeDescriptor
6049  s_typeDescriptor;
6050 
6051  void
6052  decodeFields (
6053  CDecoderStream * pDecoderStream);
6054 
6055  void
6056  assimilateSubParameters (
6057  CErrorDetails * pError);
6058 
6059  void
6060  encode (
6061  CEncoderStream * pEncoderStream) const;
6062 
6063 
6064  llrp_bool_t
6065  isAllowedIn (
6066  const CTypeDescriptor * pEnclosingElementType) const;
6067 
6068 
6069  static CElement *
6070  s_construct (void);
6071 
6072  static void
6073  s_decodeFields (
6074  CDecoderStream * pDecoderStream,
6075  CElement * pElement);
6077 
6078 
6079  protected:
6080  EImpinjSerializedTIDMode m_eSerializedTIDMode;
6081 
6084  public:
6085  static const CFieldDescriptor
6086  s_fdSerializedTIDMode;
6088 
6090  inline EImpinjSerializedTIDMode
6092  {
6093  return m_eSerializedTIDMode;
6094  }
6095 
6097  inline void
6099  EImpinjSerializedTIDMode value)
6100  {
6101  m_eSerializedTIDMode = value;
6102  }
6103 
6104 
6105 
6106  protected:
6107  std::list<CParameter *> m_listCustom;
6108 
6109  public:
6111  inline std::list<CParameter *>::iterator
6113  {
6114  return m_listCustom.begin();
6115  }
6116 
6118  inline std::list<CParameter *>::iterator
6119  endCustom (void)
6120  {
6121  return m_listCustom.end();
6122  }
6123 
6125  inline void
6127  {
6128  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6129  }
6130 
6132  inline int
6134  {
6135  return (int) (m_listCustom.size());
6136  }
6137 
6138  EResultCode
6140  addCustom (
6141  CParameter * pValue);
6142 
6143 
6144 };
6145 
6146 
6170 class CImpinjEnableRFPhaseAngle : public CParameter
6171 {
6172  public:
6174  ~CImpinjEnableRFPhaseAngle (void);
6175 
6178 
6179  static const CFieldDescriptor * const
6180  s_apFieldDescriptorTable[];
6181 
6182  static const CTypeDescriptor
6183  s_typeDescriptor;
6184 
6185  void
6186  decodeFields (
6187  CDecoderStream * pDecoderStream);
6188 
6189  void
6190  assimilateSubParameters (
6191  CErrorDetails * pError);
6192 
6193  void
6194  encode (
6195  CEncoderStream * pEncoderStream) const;
6196 
6197 
6198  llrp_bool_t
6199  isAllowedIn (
6200  const CTypeDescriptor * pEnclosingElementType) const;
6201 
6202 
6203  static CElement *
6204  s_construct (void);
6205 
6206  static void
6207  s_decodeFields (
6208  CDecoderStream * pDecoderStream,
6209  CElement * pElement);
6211 
6212 
6213  protected:
6214  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
6215 
6218  public:
6219  static const CFieldDescriptor
6220  s_fdRFPhaseAngleMode;
6222 
6224  inline EImpinjRFPhaseAngleMode
6226  {
6227  return m_eRFPhaseAngleMode;
6228  }
6229 
6231  inline void
6233  EImpinjRFPhaseAngleMode value)
6234  {
6235  m_eRFPhaseAngleMode = value;
6236  }
6237 
6238 
6239 
6240  protected:
6241  std::list<CParameter *> m_listCustom;
6242 
6243  public:
6245  inline std::list<CParameter *>::iterator
6247  {
6248  return m_listCustom.begin();
6249  }
6250 
6252  inline std::list<CParameter *>::iterator
6253  endCustom (void)
6254  {
6255  return m_listCustom.end();
6256  }
6257 
6259  inline void
6261  {
6262  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6263  }
6264 
6266  inline int
6268  {
6269  return (int) (m_listCustom.size());
6270  }
6271 
6272  EResultCode
6274  addCustom (
6275  CParameter * pValue);
6276 
6277 
6278 };
6279 
6280 
6304 class CImpinjEnablePeakRSSI : public CParameter
6305 {
6306  public:
6307  CImpinjEnablePeakRSSI (void);
6308  ~CImpinjEnablePeakRSSI (void);
6309 
6312 
6313  static const CFieldDescriptor * const
6314  s_apFieldDescriptorTable[];
6315 
6316  static const CTypeDescriptor
6317  s_typeDescriptor;
6318 
6319  void
6320  decodeFields (
6321  CDecoderStream * pDecoderStream);
6322 
6323  void
6324  assimilateSubParameters (
6325  CErrorDetails * pError);
6326 
6327  void
6328  encode (
6329  CEncoderStream * pEncoderStream) const;
6330 
6331 
6332  llrp_bool_t
6333  isAllowedIn (
6334  const CTypeDescriptor * pEnclosingElementType) const;
6335 
6336 
6337  static CElement *
6338  s_construct (void);
6339 
6340  static void
6341  s_decodeFields (
6342  CDecoderStream * pDecoderStream,
6343  CElement * pElement);
6345 
6346 
6347  protected:
6348  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6349 
6352  public:
6353  static const CFieldDescriptor
6354  s_fdPeakRSSIMode;
6356 
6358  inline EImpinjPeakRSSIMode
6360  {
6361  return m_ePeakRSSIMode;
6362  }
6363 
6365  inline void
6367  EImpinjPeakRSSIMode value)
6368  {
6369  m_ePeakRSSIMode = value;
6370  }
6371 
6372 
6373 
6374  protected:
6375  std::list<CParameter *> m_listCustom;
6376 
6377  public:
6379  inline std::list<CParameter *>::iterator
6381  {
6382  return m_listCustom.begin();
6383  }
6384 
6386  inline std::list<CParameter *>::iterator
6387  endCustom (void)
6388  {
6389  return m_listCustom.end();
6390  }
6391 
6393  inline void
6395  {
6396  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6397  }
6398 
6400  inline int
6402  {
6403  return (int) (m_listCustom.size());
6404  }
6405 
6406  EResultCode
6408  addCustom (
6409  CParameter * pValue);
6410 
6411 
6412 };
6413 
6414 
6438 class CImpinjEnableGPSCoordinates : public CParameter
6439 {
6440  public:
6443 
6446 
6447  static const CFieldDescriptor * const
6448  s_apFieldDescriptorTable[];
6449 
6450  static const CTypeDescriptor
6451  s_typeDescriptor;
6452 
6453  void
6454  decodeFields (
6455  CDecoderStream * pDecoderStream);
6456 
6457  void
6458  assimilateSubParameters (
6459  CErrorDetails * pError);
6460 
6461  void
6462  encode (
6463  CEncoderStream * pEncoderStream) const;
6464 
6465 
6466  llrp_bool_t
6467  isAllowedIn (
6468  const CTypeDescriptor * pEnclosingElementType) const;
6469 
6470 
6471  static CElement *
6472  s_construct (void);
6473 
6474  static void
6475  s_decodeFields (
6476  CDecoderStream * pDecoderStream,
6477  CElement * pElement);
6479 
6480 
6481  protected:
6482  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6483 
6486  public:
6487  static const CFieldDescriptor
6488  s_fdGPSCoordinatesMode;
6490 
6492  inline EImpinjGPSCoordinatesMode
6494  {
6495  return m_eGPSCoordinatesMode;
6496  }
6497 
6499  inline void
6501  EImpinjGPSCoordinatesMode value)
6502  {
6503  m_eGPSCoordinatesMode = value;
6504  }
6505 
6506 
6507 
6508  protected:
6509  std::list<CParameter *> m_listCustom;
6510 
6511  public:
6513  inline std::list<CParameter *>::iterator
6515  {
6516  return m_listCustom.begin();
6517  }
6518 
6520  inline std::list<CParameter *>::iterator
6521  endCustom (void)
6522  {
6523  return m_listCustom.end();
6524  }
6525 
6527  inline void
6529  {
6530  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6531  }
6532 
6534  inline int
6536  {
6537  return (int) (m_listCustom.size());
6538  }
6539 
6540  EResultCode
6542  addCustom (
6543  CParameter * pValue);
6544 
6545 
6546 };
6547 
6548 
6574 class CImpinjSerializedTID : public CParameter
6575 {
6576  public:
6577  CImpinjSerializedTID (void);
6578  ~CImpinjSerializedTID (void);
6579 
6582 
6583  static const CFieldDescriptor * const
6584  s_apFieldDescriptorTable[];
6585 
6586  static const CTypeDescriptor
6587  s_typeDescriptor;
6588 
6589  void
6590  decodeFields (
6591  CDecoderStream * pDecoderStream);
6592 
6593  void
6594  assimilateSubParameters (
6595  CErrorDetails * pError);
6596 
6597  void
6598  encode (
6599  CEncoderStream * pEncoderStream) const;
6600 
6601 
6602  llrp_bool_t
6603  isAllowedIn (
6604  const CTypeDescriptor * pEnclosingElementType) const;
6605 
6606 
6607  static CElement *
6608  s_construct (void);
6609 
6610  static void
6611  s_decodeFields (
6612  CDecoderStream * pDecoderStream,
6613  CElement * pElement);
6615 
6616 
6617  protected:
6618  llrp_u16v_t m_TID;
6619 
6622  public:
6623  static const CFieldDescriptor
6624  s_fdTID;
6626 
6628  inline llrp_u16v_t
6629  getTID (void)
6630  {
6631  return m_TID;
6632  }
6633 
6635  inline void
6637  llrp_u16v_t value)
6638  {
6639  m_TID = value;
6640  }
6641 
6642 
6643 
6644  protected:
6645  CImpinjTIDParity * m_pImpinjTIDParity;
6646 
6647  public:
6649  inline CImpinjTIDParity *
6651  {
6652  return m_pImpinjTIDParity;
6653  }
6654 
6656  EResultCode
6657  setImpinjTIDParity (
6658  CImpinjTIDParity * pValue);
6659 
6660 
6661  protected:
6662  std::list<CParameter *> m_listCustom;
6663 
6664  public:
6666  inline std::list<CParameter *>::iterator
6668  {
6669  return m_listCustom.begin();
6670  }
6671 
6673  inline std::list<CParameter *>::iterator
6674  endCustom (void)
6675  {
6676  return m_listCustom.end();
6677  }
6678 
6680  inline void
6682  {
6683  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6684  }
6685 
6687  inline int
6689  {
6690  return (int) (m_listCustom.size());
6691  }
6692 
6693  EResultCode
6695  addCustom (
6696  CParameter * pValue);
6697 
6698 
6699 };
6700 
6701 
6726 class CImpinjRFPhaseAngle : public CParameter
6727 {
6728  public:
6729  CImpinjRFPhaseAngle (void);
6730  ~CImpinjRFPhaseAngle (void);
6731 
6734 
6735  static const CFieldDescriptor * const
6736  s_apFieldDescriptorTable[];
6737 
6738  static const CTypeDescriptor
6739  s_typeDescriptor;
6740 
6741  void
6742  decodeFields (
6743  CDecoderStream * pDecoderStream);
6744 
6745  void
6746  assimilateSubParameters (
6747  CErrorDetails * pError);
6748 
6749  void
6750  encode (
6751  CEncoderStream * pEncoderStream) const;
6752 
6753 
6754  llrp_bool_t
6755  isAllowedIn (
6756  const CTypeDescriptor * pEnclosingElementType) const;
6757 
6758 
6759  static CElement *
6760  s_construct (void);
6761 
6762  static void
6763  s_decodeFields (
6764  CDecoderStream * pDecoderStream,
6765  CElement * pElement);
6767 
6768 
6769  protected:
6770  llrp_u16_t m_PhaseAngle;
6771 
6774  public:
6775  static const CFieldDescriptor
6776  s_fdPhaseAngle;
6778 
6780  inline llrp_u16_t
6782  {
6783  return m_PhaseAngle;
6784  }
6785 
6787  inline void
6789  llrp_u16_t value)
6790  {
6791  m_PhaseAngle = value;
6792  }
6793 
6794 
6795 
6796  protected:
6797  std::list<CParameter *> m_listCustom;
6798 
6799  public:
6801  inline std::list<CParameter *>::iterator
6803  {
6804  return m_listCustom.begin();
6805  }
6806 
6808  inline std::list<CParameter *>::iterator
6809  endCustom (void)
6810  {
6811  return m_listCustom.end();
6812  }
6813 
6815  inline void
6817  {
6818  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6819  }
6820 
6822  inline int
6824  {
6825  return (int) (m_listCustom.size());
6826  }
6827 
6828  EResultCode
6830  addCustom (
6831  CParameter * pValue);
6832 
6833 
6834 };
6835 
6836 
6861 class CImpinjPeakRSSI : public CParameter
6862 {
6863  public:
6864  CImpinjPeakRSSI (void);
6865  ~CImpinjPeakRSSI (void);
6866 
6869 
6870  static const CFieldDescriptor * const
6871  s_apFieldDescriptorTable[];
6872 
6873  static const CTypeDescriptor
6874  s_typeDescriptor;
6875 
6876  void
6877  decodeFields (
6878  CDecoderStream * pDecoderStream);
6879 
6880  void
6881  assimilateSubParameters (
6882  CErrorDetails * pError);
6883 
6884  void
6885  encode (
6886  CEncoderStream * pEncoderStream) const;
6887 
6888 
6889  llrp_bool_t
6890  isAllowedIn (
6891  const CTypeDescriptor * pEnclosingElementType) const;
6892 
6893 
6894  static CElement *
6895  s_construct (void);
6896 
6897  static void
6898  s_decodeFields (
6899  CDecoderStream * pDecoderStream,
6900  CElement * pElement);
6902 
6903 
6904  protected:
6905  llrp_s16_t m_RSSI;
6906 
6909  public:
6910  static const CFieldDescriptor
6911  s_fdRSSI;
6913 
6915  inline llrp_s16_t
6916  getRSSI (void)
6917  {
6918  return m_RSSI;
6919  }
6920 
6922  inline void
6924  llrp_s16_t value)
6925  {
6926  m_RSSI = value;
6927  }
6928 
6929 
6930 
6931  protected:
6932  std::list<CParameter *> m_listCustom;
6933 
6934  public:
6936  inline std::list<CParameter *>::iterator
6938  {
6939  return m_listCustom.begin();
6940  }
6941 
6943  inline std::list<CParameter *>::iterator
6944  endCustom (void)
6945  {
6946  return m_listCustom.end();
6947  }
6948 
6950  inline void
6952  {
6953  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6954  }
6955 
6957  inline int
6959  {
6960  return (int) (m_listCustom.size());
6961  }
6962 
6963  EResultCode
6965  addCustom (
6966  CParameter * pValue);
6967 
6968 
6969 };
6970 
6971 
6997 class CImpinjGPSCoordinates : public CParameter
6998 {
6999  public:
7000  CImpinjGPSCoordinates (void);
7001  ~CImpinjGPSCoordinates (void);
7002 
7005 
7006  static const CFieldDescriptor * const
7007  s_apFieldDescriptorTable[];
7008 
7009  static const CTypeDescriptor
7010  s_typeDescriptor;
7011 
7012  void
7013  decodeFields (
7014  CDecoderStream * pDecoderStream);
7015 
7016  void
7017  assimilateSubParameters (
7018  CErrorDetails * pError);
7019 
7020  void
7021  encode (
7022  CEncoderStream * pEncoderStream) const;
7023 
7024 
7025  llrp_bool_t
7026  isAllowedIn (
7027  const CTypeDescriptor * pEnclosingElementType) const;
7028 
7029 
7030  static CElement *
7031  s_construct (void);
7032 
7033  static void
7034  s_decodeFields (
7035  CDecoderStream * pDecoderStream,
7036  CElement * pElement);
7038 
7039 
7040  protected:
7041  llrp_s32_t m_Latitude;
7042 
7045  public:
7046  static const CFieldDescriptor
7047  s_fdLatitude;
7049 
7051  inline llrp_s32_t
7053  {
7054  return m_Latitude;
7055  }
7056 
7058  inline void
7060  llrp_s32_t value)
7061  {
7062  m_Latitude = value;
7063  }
7064 
7065 
7066  protected:
7067  llrp_s32_t m_Longitude;
7068 
7071  public:
7072  static const CFieldDescriptor
7073  s_fdLongitude;
7075 
7077  inline llrp_s32_t
7079  {
7080  return m_Longitude;
7081  }
7082 
7084  inline void
7086  llrp_s32_t value)
7087  {
7088  m_Longitude = value;
7089  }
7090 
7091 
7092 
7093  protected:
7094  std::list<CParameter *> m_listCustom;
7095 
7096  public:
7098  inline std::list<CParameter *>::iterator
7100  {
7101  return m_listCustom.begin();
7102  }
7103 
7105  inline std::list<CParameter *>::iterator
7106  endCustom (void)
7107  {
7108  return m_listCustom.end();
7109  }
7110 
7112  inline void
7114  {
7115  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7116  }
7117 
7119  inline int
7121  {
7122  return (int) (m_listCustom.size());
7123  }
7124 
7125  EResultCode
7127  addCustom (
7128  CParameter * pValue);
7129 
7130 
7131 };
7132 
7133 
7158 class CImpinjLoopSpec : public CParameter
7159 {
7160  public:
7161  CImpinjLoopSpec (void);
7162  ~CImpinjLoopSpec (void);
7163 
7166 
7167  static const CFieldDescriptor * const
7168  s_apFieldDescriptorTable[];
7169 
7170  static const CTypeDescriptor
7171  s_typeDescriptor;
7172 
7173  void
7174  decodeFields (
7175  CDecoderStream * pDecoderStream);
7176 
7177  void
7178  assimilateSubParameters (
7179  CErrorDetails * pError);
7180 
7181  void
7182  encode (
7183  CEncoderStream * pEncoderStream) const;
7184 
7185 
7186  llrp_bool_t
7187  isAllowedIn (
7188  const CTypeDescriptor * pEnclosingElementType) const;
7189 
7190 
7191  static CElement *
7192  s_construct (void);
7193 
7194  static void
7195  s_decodeFields (
7196  CDecoderStream * pDecoderStream,
7197  CElement * pElement);
7199 
7200 
7201  protected:
7202  llrp_u32_t m_LoopCount;
7203 
7206  public:
7207  static const CFieldDescriptor
7208  s_fdLoopCount;
7210 
7212  inline llrp_u32_t
7214  {
7215  return m_LoopCount;
7216  }
7217 
7219  inline void
7221  llrp_u32_t value)
7222  {
7223  m_LoopCount = value;
7224  }
7225 
7226 
7227 
7228  protected:
7229  std::list<CParameter *> m_listCustom;
7230 
7231  public:
7233  inline std::list<CParameter *>::iterator
7235  {
7236  return m_listCustom.begin();
7237  }
7238 
7240  inline std::list<CParameter *>::iterator
7241  endCustom (void)
7242  {
7243  return m_listCustom.end();
7244  }
7245 
7247  inline void
7249  {
7250  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7251  }
7252 
7254  inline int
7256  {
7257  return (int) (m_listCustom.size());
7258  }
7259 
7260  EResultCode
7262  addCustom (
7263  CParameter * pValue);
7264 
7265 
7266 };
7267 
7268 
7294 class CImpinjGPSNMEASentences : public CParameter
7295 {
7296  public:
7297  CImpinjGPSNMEASentences (void);
7298  ~CImpinjGPSNMEASentences (void);
7299 
7302 
7303  static const CFieldDescriptor * const
7304  s_apFieldDescriptorTable[];
7305 
7306  static const CTypeDescriptor
7307  s_typeDescriptor;
7308 
7309  void
7310  decodeFields (
7311  CDecoderStream * pDecoderStream);
7312 
7313  void
7314  assimilateSubParameters (
7315  CErrorDetails * pError);
7316 
7317  void
7318  encode (
7319  CEncoderStream * pEncoderStream) const;
7320 
7321 
7322  llrp_bool_t
7323  isAllowedIn (
7324  const CTypeDescriptor * pEnclosingElementType) const;
7325 
7326 
7327  static CElement *
7328  s_construct (void);
7329 
7330  static void
7331  s_decodeFields (
7332  CDecoderStream * pDecoderStream,
7333  CElement * pElement);
7335 
7336 
7337 
7338  protected:
7339  CImpinjGGASentence * m_pImpinjGGASentence;
7340 
7341  public:
7343  inline CImpinjGGASentence *
7345  {
7346  return m_pImpinjGGASentence;
7347  }
7348 
7350  EResultCode
7351  setImpinjGGASentence (
7352  CImpinjGGASentence * pValue);
7353 
7354 
7355  protected:
7356  CImpinjRMCSentence * m_pImpinjRMCSentence;
7357 
7358  public:
7360  inline CImpinjRMCSentence *
7362  {
7363  return m_pImpinjRMCSentence;
7364  }
7365 
7367  EResultCode
7368  setImpinjRMCSentence (
7369  CImpinjRMCSentence * pValue);
7370 
7371 
7372  protected:
7373  std::list<CParameter *> m_listCustom;
7374 
7375  public:
7377  inline std::list<CParameter *>::iterator
7379  {
7380  return m_listCustom.begin();
7381  }
7382 
7384  inline std::list<CParameter *>::iterator
7385  endCustom (void)
7386  {
7387  return m_listCustom.end();
7388  }
7389 
7391  inline void
7393  {
7394  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7395  }
7396 
7398  inline int
7400  {
7401  return (int) (m_listCustom.size());
7402  }
7403 
7404  EResultCode
7406  addCustom (
7407  CParameter * pValue);
7408 
7409 
7410 };
7411 
7412 
7436 class CImpinjGGASentence : public CParameter
7437 {
7438  public:
7439  CImpinjGGASentence (void);
7440  ~CImpinjGGASentence (void);
7441 
7444 
7445  static const CFieldDescriptor * const
7446  s_apFieldDescriptorTable[];
7447 
7448  static const CTypeDescriptor
7449  s_typeDescriptor;
7450 
7451  void
7452  decodeFields (
7453  CDecoderStream * pDecoderStream);
7454 
7455  void
7456  assimilateSubParameters (
7457  CErrorDetails * pError);
7458 
7459  void
7460  encode (
7461  CEncoderStream * pEncoderStream) const;
7462 
7463 
7464  llrp_bool_t
7465  isAllowedIn (
7466  const CTypeDescriptor * pEnclosingElementType) const;
7467 
7468 
7469  static CElement *
7470  s_construct (void);
7471 
7472  static void
7473  s_decodeFields (
7474  CDecoderStream * pDecoderStream,
7475  CElement * pElement);
7477 
7478 
7479  protected:
7480  llrp_utf8v_t m_GGASentence;
7481 
7484  public:
7485  static const CFieldDescriptor
7486  s_fdGGASentence;
7488 
7490  inline llrp_utf8v_t
7492  {
7493  return m_GGASentence;
7494  }
7495 
7497  inline void
7499  llrp_utf8v_t value)
7500  {
7501  m_GGASentence = value;
7502  }
7503 
7504 
7505 
7506  protected:
7507  std::list<CParameter *> m_listCustom;
7508 
7509  public:
7511  inline std::list<CParameter *>::iterator
7513  {
7514  return m_listCustom.begin();
7515  }
7516 
7518  inline std::list<CParameter *>::iterator
7519  endCustom (void)
7520  {
7521  return m_listCustom.end();
7522  }
7523 
7525  inline void
7527  {
7528  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7529  }
7530 
7532  inline int
7534  {
7535  return (int) (m_listCustom.size());
7536  }
7537 
7538  EResultCode
7540  addCustom (
7541  CParameter * pValue);
7542 
7543 
7544 };
7545 
7546 
7570 class CImpinjRMCSentence : public CParameter
7571 {
7572  public:
7573  CImpinjRMCSentence (void);
7574  ~CImpinjRMCSentence (void);
7575 
7578 
7579  static const CFieldDescriptor * const
7580  s_apFieldDescriptorTable[];
7581 
7582  static const CTypeDescriptor
7583  s_typeDescriptor;
7584 
7585  void
7586  decodeFields (
7587  CDecoderStream * pDecoderStream);
7588 
7589  void
7590  assimilateSubParameters (
7591  CErrorDetails * pError);
7592 
7593  void
7594  encode (
7595  CEncoderStream * pEncoderStream) const;
7596 
7597 
7598  llrp_bool_t
7599  isAllowedIn (
7600  const CTypeDescriptor * pEnclosingElementType) const;
7601 
7602 
7603  static CElement *
7604  s_construct (void);
7605 
7606  static void
7607  s_decodeFields (
7608  CDecoderStream * pDecoderStream,
7609  CElement * pElement);
7611 
7612 
7613  protected:
7614  llrp_utf8v_t m_RMCSentence;
7615 
7618  public:
7619  static const CFieldDescriptor
7620  s_fdRMCSentence;
7622 
7624  inline llrp_utf8v_t
7626  {
7627  return m_RMCSentence;
7628  }
7629 
7631  inline void
7633  llrp_utf8v_t value)
7634  {
7635  m_RMCSentence = value;
7636  }
7637 
7638 
7639 
7640  protected:
7641  std::list<CParameter *> m_listCustom;
7642 
7643  public:
7645  inline std::list<CParameter *>::iterator
7647  {
7648  return m_listCustom.begin();
7649  }
7650 
7652  inline std::list<CParameter *>::iterator
7653  endCustom (void)
7654  {
7655  return m_listCustom.end();
7656  }
7657 
7659  inline void
7661  {
7662  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7663  }
7664 
7666  inline int
7668  {
7669  return (int) (m_listCustom.size());
7670  }
7671 
7672  EResultCode
7674  addCustom (
7675  CParameter * pValue);
7676 
7677 
7678 };
7679 
7680 
7704 class CImpinjOpSpecRetryCount : public CParameter
7705 {
7706  public:
7707  CImpinjOpSpecRetryCount (void);
7708  ~CImpinjOpSpecRetryCount (void);
7709 
7712 
7713  static const CFieldDescriptor * const
7714  s_apFieldDescriptorTable[];
7715 
7716  static const CTypeDescriptor
7717  s_typeDescriptor;
7718 
7719  void
7720  decodeFields (
7721  CDecoderStream * pDecoderStream);
7722 
7723  void
7724  assimilateSubParameters (
7725  CErrorDetails * pError);
7726 
7727  void
7728  encode (
7729  CEncoderStream * pEncoderStream) const;
7730 
7731 
7732  llrp_bool_t
7733  isAllowedIn (
7734  const CTypeDescriptor * pEnclosingElementType) const;
7735 
7736 
7737  static CElement *
7738  s_construct (void);
7739 
7740  static void
7741  s_decodeFields (
7742  CDecoderStream * pDecoderStream,
7743  CElement * pElement);
7745 
7746 
7747  protected:
7748  llrp_u16_t m_RetryCount;
7749 
7752  public:
7753  static const CFieldDescriptor
7754  s_fdRetryCount;
7756 
7758  inline llrp_u16_t
7760  {
7761  return m_RetryCount;
7762  }
7763 
7765  inline void
7767  llrp_u16_t value)
7768  {
7769  m_RetryCount = value;
7770  }
7771 
7772 
7773 
7774  protected:
7775  std::list<CParameter *> m_listCustom;
7776 
7777  public:
7779  inline std::list<CParameter *>::iterator
7781  {
7782  return m_listCustom.begin();
7783  }
7784 
7786  inline std::list<CParameter *>::iterator
7787  endCustom (void)
7788  {
7789  return m_listCustom.end();
7790  }
7791 
7793  inline void
7795  {
7796  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7797  }
7798 
7800  inline int
7802  {
7803  return (int) (m_listCustom.size());
7804  }
7805 
7806  EResultCode
7808  addCustom (
7809  CParameter * pValue);
7810 
7811 
7812 };
7813 
7814 
7842 class CImpinjAdvancedGPOConfiguration : public CParameter
7843 {
7844  public:
7847 
7850 
7851  static const CFieldDescriptor * const
7852  s_apFieldDescriptorTable[];
7853 
7854  static const CTypeDescriptor
7855  s_typeDescriptor;
7856 
7857  void
7858  decodeFields (
7859  CDecoderStream * pDecoderStream);
7860 
7861  void
7862  assimilateSubParameters (
7863  CErrorDetails * pError);
7864 
7865  void
7866  encode (
7867  CEncoderStream * pEncoderStream) const;
7868 
7869 
7870  llrp_bool_t
7871  isAllowedIn (
7872  const CTypeDescriptor * pEnclosingElementType) const;
7873 
7874 
7875  static CElement *
7876  s_construct (void);
7877 
7878  static void
7879  s_decodeFields (
7880  CDecoderStream * pDecoderStream,
7881  CElement * pElement);
7883 
7884 
7885  protected:
7886  llrp_u16_t m_GPOPortNum;
7887 
7890  public:
7891  static const CFieldDescriptor
7892  s_fdGPOPortNum;
7894 
7896  inline llrp_u16_t
7898  {
7899  return m_GPOPortNum;
7900  }
7901 
7903  inline void
7905  llrp_u16_t value)
7906  {
7907  m_GPOPortNum = value;
7908  }
7909 
7910 
7911  protected:
7912  EImpinjAdvancedGPOMode m_eGPOMode;
7913 
7916  public:
7917  static const CFieldDescriptor
7918  s_fdGPOMode;
7920 
7922  inline EImpinjAdvancedGPOMode
7923  getGPOMode (void)
7924  {
7925  return m_eGPOMode;
7926  }
7927 
7929  inline void
7931  EImpinjAdvancedGPOMode value)
7932  {
7933  m_eGPOMode = value;
7934  }
7935 
7936 
7937  protected:
7938  llrp_u32_t m_GPOPulseDurationMSec;
7939 
7942  public:
7943  static const CFieldDescriptor
7944  s_fdGPOPulseDurationMSec;
7946 
7948  inline llrp_u32_t
7950  {
7951  return m_GPOPulseDurationMSec;
7952  }
7953 
7955  inline void
7957  llrp_u32_t value)
7958  {
7959  m_GPOPulseDurationMSec = value;
7960  }
7961 
7962 
7963 
7964  protected:
7965  std::list<CParameter *> m_listCustom;
7966 
7967  public:
7969  inline std::list<CParameter *>::iterator
7971  {
7972  return m_listCustom.begin();
7973  }
7974 
7976  inline std::list<CParameter *>::iterator
7977  endCustom (void)
7978  {
7979  return m_listCustom.end();
7980  }
7981 
7983  inline void
7985  {
7986  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7987  }
7988 
7990  inline int
7992  {
7993  return (int) (m_listCustom.size());
7994  }
7995 
7996  EResultCode
7998  addCustom (
7999  CParameter * pValue);
8000 
8001 
8002 };
8003 
8004 
8038 class CImpinjEnableOptimizedRead : public CParameter
8039 {
8040  public:
8043 
8046 
8047  static const CFieldDescriptor * const
8048  s_apFieldDescriptorTable[];
8049 
8050  static const CTypeDescriptor
8051  s_typeDescriptor;
8052 
8053  void
8054  decodeFields (
8055  CDecoderStream * pDecoderStream);
8056 
8057  void
8058  assimilateSubParameters (
8059  CErrorDetails * pError);
8060 
8061  void
8062  encode (
8063  CEncoderStream * pEncoderStream) const;
8064 
8065 
8066  llrp_bool_t
8067  isAllowedIn (
8068  const CTypeDescriptor * pEnclosingElementType) const;
8069 
8070 
8071  static CElement *
8072  s_construct (void);
8073 
8074  static void
8075  s_decodeFields (
8076  CDecoderStream * pDecoderStream,
8077  CElement * pElement);
8079 
8080 
8081  protected:
8082  EImpinjOptimizedReadMode m_eOptimizedReadMode;
8083 
8086  public:
8087  static const CFieldDescriptor
8088  s_fdOptimizedReadMode;
8090 
8092  inline EImpinjOptimizedReadMode
8094  {
8095  return m_eOptimizedReadMode;
8096  }
8097 
8099  inline void
8101  EImpinjOptimizedReadMode value)
8102  {
8103  m_eOptimizedReadMode = value;
8104  }
8105 
8106 
8107 
8108  protected:
8109  std::list<CC1G2Read *> m_listC1G2Read;
8110 
8111  public:
8113  inline std::list<CC1G2Read *>::iterator
8115  {
8116  return m_listC1G2Read.begin();
8117  }
8118 
8120  inline std::list<CC1G2Read *>::iterator
8122  {
8123  return m_listC1G2Read.end();
8124  }
8125 
8127  inline void
8129  {
8130  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
8131  }
8132 
8134  inline int
8136  {
8137  return (int) (m_listC1G2Read.size());
8138  }
8139 
8140  EResultCode
8142  addC1G2Read (
8143  CC1G2Read * pValue);
8144 
8145 
8146  protected:
8147  std::list<CParameter *> m_listCustom;
8148 
8149  public:
8151  inline std::list<CParameter *>::iterator
8153  {
8154  return m_listCustom.begin();
8155  }
8156 
8158  inline std::list<CParameter *>::iterator
8159  endCustom (void)
8160  {
8161  return m_listCustom.end();
8162  }
8163 
8165  inline void
8167  {
8168  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8169  }
8170 
8172  inline int
8174  {
8175  return (int) (m_listCustom.size());
8176  }
8177 
8178  EResultCode
8180  addCustom (
8181  CParameter * pValue);
8182 
8183 
8184 };
8185 
8186 
8213 class CImpinjAccessSpecOrdering : public CParameter
8214 {
8215  public:
8217  ~CImpinjAccessSpecOrdering (void);
8218 
8221 
8222  static const CFieldDescriptor * const
8223  s_apFieldDescriptorTable[];
8224 
8225  static const CTypeDescriptor
8226  s_typeDescriptor;
8227 
8228  void
8229  decodeFields (
8230  CDecoderStream * pDecoderStream);
8231 
8232  void
8233  assimilateSubParameters (
8234  CErrorDetails * pError);
8235 
8236  void
8237  encode (
8238  CEncoderStream * pEncoderStream) const;
8239 
8240 
8241  llrp_bool_t
8242  isAllowedIn (
8243  const CTypeDescriptor * pEnclosingElementType) const;
8244 
8245 
8246  static CElement *
8247  s_construct (void);
8248 
8249  static void
8250  s_decodeFields (
8251  CDecoderStream * pDecoderStream,
8252  CElement * pElement);
8254 
8255 
8256  protected:
8257  EImpinjAccessSpecOrderingMode m_eOrderingMode;
8258 
8261  public:
8262  static const CFieldDescriptor
8263  s_fdOrderingMode;
8265 
8267  inline EImpinjAccessSpecOrderingMode
8269  {
8270  return m_eOrderingMode;
8271  }
8272 
8274  inline void
8276  EImpinjAccessSpecOrderingMode value)
8277  {
8278  m_eOrderingMode = value;
8279  }
8280 
8281 
8282 
8283  protected:
8284  std::list<CParameter *> m_listCustom;
8285 
8286  public:
8288  inline std::list<CParameter *>::iterator
8290  {
8291  return m_listCustom.begin();
8292  }
8293 
8295  inline std::list<CParameter *>::iterator
8296  endCustom (void)
8297  {
8298  return m_listCustom.end();
8299  }
8300 
8302  inline void
8304  {
8305  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8306  }
8307 
8309  inline int
8311  {
8312  return (int) (m_listCustom.size());
8313  }
8314 
8315  EResultCode
8317  addCustom (
8318  CParameter * pValue);
8319 
8320 
8321 };
8322 
8323 
8347 class CImpinjEnableRFDopplerFrequency : public CParameter
8348 {
8349  public:
8352 
8355 
8356  static const CFieldDescriptor * const
8357  s_apFieldDescriptorTable[];
8358 
8359  static const CTypeDescriptor
8360  s_typeDescriptor;
8361 
8362  void
8363  decodeFields (
8364  CDecoderStream * pDecoderStream);
8365 
8366  void
8367  assimilateSubParameters (
8368  CErrorDetails * pError);
8369 
8370  void
8371  encode (
8372  CEncoderStream * pEncoderStream) const;
8373 
8374 
8375  llrp_bool_t
8376  isAllowedIn (
8377  const CTypeDescriptor * pEnclosingElementType) const;
8378 
8379 
8380  static CElement *
8381  s_construct (void);
8382 
8383  static void
8384  s_decodeFields (
8385  CDecoderStream * pDecoderStream,
8386  CElement * pElement);
8388 
8389 
8390  protected:
8391  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8392 
8395  public:
8396  static const CFieldDescriptor
8397  s_fdRFDopplerFrequencyMode;
8399 
8401  inline EImpinjRFDopplerFrequencyMode
8403  {
8404  return m_eRFDopplerFrequencyMode;
8405  }
8406 
8408  inline void
8410  EImpinjRFDopplerFrequencyMode value)
8411  {
8412  m_eRFDopplerFrequencyMode = value;
8413  }
8414 
8415 
8416 
8417  protected:
8418  std::list<CParameter *> m_listCustom;
8419 
8420  public:
8422  inline std::list<CParameter *>::iterator
8424  {
8425  return m_listCustom.begin();
8426  }
8427 
8429  inline std::list<CParameter *>::iterator
8430  endCustom (void)
8431  {
8432  return m_listCustom.end();
8433  }
8434 
8436  inline void
8438  {
8439  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8440  }
8441 
8443  inline int
8445  {
8446  return (int) (m_listCustom.size());
8447  }
8448 
8449  EResultCode
8451  addCustom (
8452  CParameter * pValue);
8453 
8454 
8455 };
8456 
8457 
8482 class CImpinjRFDopplerFrequency : public CParameter
8483 {
8484  public:
8486  ~CImpinjRFDopplerFrequency (void);
8487 
8490 
8491  static const CFieldDescriptor * const
8492  s_apFieldDescriptorTable[];
8493 
8494  static const CTypeDescriptor
8495  s_typeDescriptor;
8496 
8497  void
8498  decodeFields (
8499  CDecoderStream * pDecoderStream);
8500 
8501  void
8502  assimilateSubParameters (
8503  CErrorDetails * pError);
8504 
8505  void
8506  encode (
8507  CEncoderStream * pEncoderStream) const;
8508 
8509 
8510  llrp_bool_t
8511  isAllowedIn (
8512  const CTypeDescriptor * pEnclosingElementType) const;
8513 
8514 
8515  static CElement *
8516  s_construct (void);
8517 
8518  static void
8519  s_decodeFields (
8520  CDecoderStream * pDecoderStream,
8521  CElement * pElement);
8523 
8524 
8525  protected:
8526  llrp_s16_t m_DopplerFrequency;
8527 
8530  public:
8531  static const CFieldDescriptor
8532  s_fdDopplerFrequency;
8534 
8536  inline llrp_s16_t
8538  {
8539  return m_DopplerFrequency;
8540  }
8541 
8543  inline void
8545  llrp_s16_t value)
8546  {
8547  m_DopplerFrequency = value;
8548  }
8549 
8550 
8551 
8552  protected:
8553  std::list<CParameter *> m_listCustom;
8554 
8555  public:
8557  inline std::list<CParameter *>::iterator
8559  {
8560  return m_listCustom.begin();
8561  }
8562 
8564  inline std::list<CParameter *>::iterator
8565  endCustom (void)
8566  {
8567  return m_listCustom.end();
8568  }
8569 
8571  inline void
8573  {
8574  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8575  }
8576 
8578  inline int
8580  {
8581  return (int) (m_listCustom.size());
8582  }
8583 
8584  EResultCode
8586  addCustom (
8587  CParameter * pValue);
8588 
8589 
8590 };
8591 
8592 
8625 class CImpinjInventoryConfiguration : public CParameter
8626 {
8627  public:
8630 
8633 
8634  static const CFieldDescriptor * const
8635  s_apFieldDescriptorTable[];
8636 
8637  static const CTypeDescriptor
8638  s_typeDescriptor;
8639 
8640  void
8641  decodeFields (
8642  CDecoderStream * pDecoderStream);
8643 
8644  void
8645  assimilateSubParameters (
8646  CErrorDetails * pError);
8647 
8648  void
8649  encode (
8650  CEncoderStream * pEncoderStream) const;
8651 
8652 
8653  llrp_bool_t
8654  isAllowedIn (
8655  const CTypeDescriptor * pEnclosingElementType) const;
8656 
8657 
8658  static CElement *
8659  s_construct (void);
8660 
8661  static void
8662  s_decodeFields (
8663  CDecoderStream * pDecoderStream,
8664  CElement * pElement);
8666 
8667 
8668  protected:
8669  llrp_u1_t m_EnableAntDwellTimeLimit;
8670 
8673  public:
8674  static const CFieldDescriptor
8675  s_fdEnableAntDwellTimeLimit;
8677 
8679  inline llrp_u1_t
8681  {
8682  return m_EnableAntDwellTimeLimit;
8683  }
8684 
8686  inline void
8688  llrp_u1_t value)
8689  {
8690  m_EnableAntDwellTimeLimit = value;
8691  }
8692 
8693 
8694  protected:
8695  llrp_u1_t m_EnableSelectGapClose;
8696 
8699  public:
8700  static const CFieldDescriptor
8701  s_fdEnableSelectGapClose;
8703 
8705  inline llrp_u1_t
8707  {
8708  return m_EnableSelectGapClose;
8709  }
8710 
8712  inline void
8714  llrp_u1_t value)
8715  {
8716  m_EnableSelectGapClose = value;
8717  }
8718 
8719 
8720 
8721  protected:
8722  std::list<CParameter *> m_listCustom;
8723 
8724  public:
8726  inline std::list<CParameter *>::iterator
8728  {
8729  return m_listCustom.begin();
8730  }
8731 
8733  inline std::list<CParameter *>::iterator
8734  endCustom (void)
8735  {
8736  return m_listCustom.end();
8737  }
8738 
8740  inline void
8742  {
8743  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8744  }
8745 
8747  inline int
8749  {
8750  return (int) (m_listCustom.size());
8751  }
8752 
8753  EResultCode
8755  addCustom (
8756  CParameter * pValue);
8757 
8758 
8759 };
8760 
8761 
8785 class CImpinjEnableTxPower : public CParameter
8786 {
8787  public:
8788  CImpinjEnableTxPower (void);
8789  ~CImpinjEnableTxPower (void);
8790 
8793 
8794  static const CFieldDescriptor * const
8795  s_apFieldDescriptorTable[];
8796 
8797  static const CTypeDescriptor
8798  s_typeDescriptor;
8799 
8800  void
8801  decodeFields (
8802  CDecoderStream * pDecoderStream);
8803 
8804  void
8805  assimilateSubParameters (
8806  CErrorDetails * pError);
8807 
8808  void
8809  encode (
8810  CEncoderStream * pEncoderStream) const;
8811 
8812 
8813  llrp_bool_t
8814  isAllowedIn (
8815  const CTypeDescriptor * pEnclosingElementType) const;
8816 
8817 
8818  static CElement *
8819  s_construct (void);
8820 
8821  static void
8822  s_decodeFields (
8823  CDecoderStream * pDecoderStream,
8824  CElement * pElement);
8826 
8827 
8828  protected:
8829  EImpinjTxPowerReportingModeEnum m_eTxPowerReportingMode;
8830 
8833  public:
8834  static const CFieldDescriptor
8835  s_fdTxPowerReportingMode;
8837 
8839  inline EImpinjTxPowerReportingModeEnum
8841  {
8842  return m_eTxPowerReportingMode;
8843  }
8844 
8846  inline void
8848  EImpinjTxPowerReportingModeEnum value)
8849  {
8850  m_eTxPowerReportingMode = value;
8851  }
8852 
8853 
8854 
8855  protected:
8856  std::list<CParameter *> m_listCustom;
8857 
8858  public:
8860  inline std::list<CParameter *>::iterator
8862  {
8863  return m_listCustom.begin();
8864  }
8865 
8867  inline std::list<CParameter *>::iterator
8868  endCustom (void)
8869  {
8870  return m_listCustom.end();
8871  }
8872 
8874  inline void
8876  {
8877  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8878  }
8879 
8881  inline int
8883  {
8884  return (int) (m_listCustom.size());
8885  }
8886 
8887  EResultCode
8889  addCustom (
8890  CParameter * pValue);
8891 
8892 
8893 };
8894 
8895 
8920 class CImpinjTxPower : public CParameter
8921 {
8922  public:
8923  CImpinjTxPower (void);
8924  ~CImpinjTxPower (void);
8925 
8928 
8929  static const CFieldDescriptor * const
8930  s_apFieldDescriptorTable[];
8931 
8932  static const CTypeDescriptor
8933  s_typeDescriptor;
8934 
8935  void
8936  decodeFields (
8937  CDecoderStream * pDecoderStream);
8938 
8939  void
8940  assimilateSubParameters (
8941  CErrorDetails * pError);
8942 
8943  void
8944  encode (
8945  CEncoderStream * pEncoderStream) const;
8946 
8947 
8948  llrp_bool_t
8949  isAllowedIn (
8950  const CTypeDescriptor * pEnclosingElementType) const;
8951 
8952 
8953  static CElement *
8954  s_construct (void);
8955 
8956  static void
8957  s_decodeFields (
8958  CDecoderStream * pDecoderStream,
8959  CElement * pElement);
8961 
8962 
8963  protected:
8964  llrp_u16_t m_TxPower;
8965 
8968  public:
8969  static const CFieldDescriptor
8970  s_fdTxPower;
8972 
8974  inline llrp_u16_t
8975  getTxPower (void)
8976  {
8977  return m_TxPower;
8978  }
8979 
8981  inline void
8983  llrp_u16_t value)
8984  {
8985  m_TxPower = value;
8986  }
8987 
8988 
8989 
8990  protected:
8991  std::list<CParameter *> m_listCustom;
8992 
8993  public:
8995  inline std::list<CParameter *>::iterator
8997  {
8998  return m_listCustom.begin();
8999  }
9000 
9002  inline std::list<CParameter *>::iterator
9003  endCustom (void)
9004  {
9005  return m_listCustom.end();
9006  }
9007 
9009  inline void
9011  {
9012  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9013  }
9014 
9016  inline int
9018  {
9019  return (int) (m_listCustom.size());
9020  }
9021 
9022  EResultCode
9024  addCustom (
9025  CParameter * pValue);
9026 
9027 
9028 };
9029 
9030 
9057 class CImpinjArrayVersion : public CParameter
9058 {
9059  public:
9060  CImpinjArrayVersion (void);
9061  ~CImpinjArrayVersion (void);
9062 
9065 
9066  static const CFieldDescriptor * const
9067  s_apFieldDescriptorTable[];
9068 
9069  static const CTypeDescriptor
9070  s_typeDescriptor;
9071 
9072  void
9073  decodeFields (
9074  CDecoderStream * pDecoderStream);
9075 
9076  void
9077  assimilateSubParameters (
9078  CErrorDetails * pError);
9079 
9080  void
9081  encode (
9082  CEncoderStream * pEncoderStream) const;
9083 
9084 
9085  llrp_bool_t
9086  isAllowedIn (
9087  const CTypeDescriptor * pEnclosingElementType) const;
9088 
9089 
9090  static CElement *
9091  s_construct (void);
9092 
9093  static void
9094  s_decodeFields (
9095  CDecoderStream * pDecoderStream,
9096  CElement * pElement);
9098 
9099 
9100  protected:
9101  llrp_utf8v_t m_SerialNumber;
9102 
9105  public:
9106  static const CFieldDescriptor
9107  s_fdSerialNumber;
9109 
9111  inline llrp_utf8v_t
9113  {
9114  return m_SerialNumber;
9115  }
9116 
9118  inline void
9120  llrp_utf8v_t value)
9121  {
9122  m_SerialNumber = value;
9123  }
9124 
9125 
9126  protected:
9127  llrp_utf8v_t m_FirmwareVersion;
9128 
9131  public:
9132  static const CFieldDescriptor
9133  s_fdFirmwareVersion;
9135 
9137  inline llrp_utf8v_t
9139  {
9140  return m_FirmwareVersion;
9141  }
9142 
9144  inline void
9146  llrp_utf8v_t value)
9147  {
9148  m_FirmwareVersion = value;
9149  }
9150 
9151 
9152  protected:
9153  llrp_utf8v_t m_PCBAVersion;
9154 
9157  public:
9158  static const CFieldDescriptor
9159  s_fdPCBAVersion;
9161 
9163  inline llrp_utf8v_t
9165  {
9166  return m_PCBAVersion;
9167  }
9168 
9170  inline void
9172  llrp_utf8v_t value)
9173  {
9174  m_PCBAVersion = value;
9175  }
9176 
9177 
9178 
9179  protected:
9180  std::list<CParameter *> m_listCustom;
9181 
9182  public:
9184  inline std::list<CParameter *>::iterator
9186  {
9187  return m_listCustom.begin();
9188  }
9189 
9191  inline std::list<CParameter *>::iterator
9192  endCustom (void)
9193  {
9194  return m_listCustom.end();
9195  }
9196 
9198  inline void
9200  {
9201  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9202  }
9203 
9205  inline int
9207  {
9208  return (int) (m_listCustom.size());
9209  }
9210 
9211  EResultCode
9213  addCustom (
9214  CParameter * pValue);
9215 
9216 
9217 };
9218 
9219 
9252 class CImpinjxArrayCapabilities : public CParameter
9253 {
9254  public:
9256  ~CImpinjxArrayCapabilities (void);
9257 
9260 
9261  static const CFieldDescriptor * const
9262  s_apFieldDescriptorTable[];
9263 
9264  static const CTypeDescriptor
9265  s_typeDescriptor;
9266 
9267  void
9268  decodeFields (
9269  CDecoderStream * pDecoderStream);
9270 
9271  void
9272  assimilateSubParameters (
9273  CErrorDetails * pError);
9274 
9275  void
9276  encode (
9277  CEncoderStream * pEncoderStream) const;
9278 
9279 
9280  llrp_bool_t
9281  isAllowedIn (
9282  const CTypeDescriptor * pEnclosingElementType) const;
9283 
9284 
9285  static CElement *
9286  s_construct (void);
9287 
9288  static void
9289  s_decodeFields (
9290  CDecoderStream * pDecoderStream,
9291  CElement * pElement);
9293 
9294 
9295  protected:
9296  llrp_u32_t m_MaxNumSectors;
9297 
9300  public:
9301  static const CFieldDescriptor
9302  s_fdMaxNumSectors;
9304 
9306  inline llrp_u32_t
9308  {
9309  return m_MaxNumSectors;
9310  }
9311 
9313  inline void
9315  llrp_u32_t value)
9316  {
9317  m_MaxNumSectors = value;
9318  }
9319 
9320 
9321  protected:
9322  llrp_u1_t m_SupportsLISpecs;
9323 
9326  public:
9327  static const CFieldDescriptor
9328  s_fdSupportsLISpecs;
9330 
9332  inline llrp_u1_t
9334  {
9335  return m_SupportsLISpecs;
9336  }
9337 
9339  inline void
9341  llrp_u1_t value)
9342  {
9343  m_SupportsLISpecs = value;
9344  }
9345 
9346 
9347  protected:
9348  llrp_u1_t m_SupportsTISpecs;
9349 
9352  public:
9353  static const CFieldDescriptor
9354  s_fdSupportsTISpecs;
9356 
9358  inline llrp_u1_t
9360  {
9361  return m_SupportsTISpecs;
9362  }
9363 
9365  inline void
9367  llrp_u1_t value)
9368  {
9369  m_SupportsTISpecs = value;
9370  }
9371 
9372 
9373  protected:
9374  llrp_u1_t m_SupportsTSISpecs;
9375 
9378  public:
9379  static const CFieldDescriptor
9380  s_fdSupportsTSISpecs;
9382 
9384  inline llrp_u1_t
9386  {
9387  return m_SupportsTSISpecs;
9388  }
9389 
9391  inline void
9393  llrp_u1_t value)
9394  {
9395  m_SupportsTSISpecs = value;
9396  }
9397 
9398 
9399  protected:
9400  llrp_u1_t m_SupportsDISpecs;
9401 
9404  public:
9405  static const CFieldDescriptor
9406  s_fdSupportsDISpecs;
9408 
9410  inline llrp_u1_t
9412  {
9413  return m_SupportsDISpecs;
9414  }
9415 
9417  inline void
9419  llrp_u1_t value)
9420  {
9421  m_SupportsDISpecs = value;
9422  }
9423 
9424 
9425 
9426  protected:
9427  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
9428 
9429  public:
9433  {
9434  return m_pImpinjxArrayDirectionCapabilities;
9435  }
9436 
9438  EResultCode
9439  setImpinjxArrayDirectionCapabilities (
9441 
9442 
9443  protected:
9444  std::list<CParameter *> m_listCustom;
9445 
9446  public:
9448  inline std::list<CParameter *>::iterator
9450  {
9451  return m_listCustom.begin();
9452  }
9453 
9455  inline std::list<CParameter *>::iterator
9456  endCustom (void)
9457  {
9458  return m_listCustom.end();
9459  }
9460 
9462  inline void
9464  {
9465  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9466  }
9467 
9469  inline int
9471  {
9472  return (int) (m_listCustom.size());
9473  }
9474 
9475  EResultCode
9477  addCustom (
9478  CParameter * pValue);
9479 
9480 
9481 };
9482 
9483 
9511 class CImpinjTiltConfiguration : public CParameter
9512 {
9513  public:
9514  CImpinjTiltConfiguration (void);
9515  ~CImpinjTiltConfiguration (void);
9516 
9519 
9520  static const CFieldDescriptor * const
9521  s_apFieldDescriptorTable[];
9522 
9523  static const CTypeDescriptor
9524  s_typeDescriptor;
9525 
9526  void
9527  decodeFields (
9528  CDecoderStream * pDecoderStream);
9529 
9530  void
9531  assimilateSubParameters (
9532  CErrorDetails * pError);
9533 
9534  void
9535  encode (
9536  CEncoderStream * pEncoderStream) const;
9537 
9538 
9539  llrp_bool_t
9540  isAllowedIn (
9541  const CTypeDescriptor * pEnclosingElementType) const;
9542 
9543 
9544  static CElement *
9545  s_construct (void);
9546 
9547  static void
9548  s_decodeFields (
9549  CDecoderStream * pDecoderStream,
9550  CElement * pElement);
9552 
9553 
9554  protected:
9555  llrp_s32_t m_XAxis;
9556 
9559  public:
9560  static const CFieldDescriptor
9561  s_fdXAxis;
9563 
9565  inline llrp_s32_t
9566  getXAxis (void)
9567  {
9568  return m_XAxis;
9569  }
9570 
9572  inline void
9574  llrp_s32_t value)
9575  {
9576  m_XAxis = value;
9577  }
9578 
9579 
9580  protected:
9581  llrp_s32_t m_YAxis;
9582 
9585  public:
9586  static const CFieldDescriptor
9587  s_fdYAxis;
9589 
9591  inline llrp_s32_t
9592  getYAxis (void)
9593  {
9594  return m_YAxis;
9595  }
9596 
9598  inline void
9600  llrp_s32_t value)
9601  {
9602  m_YAxis = value;
9603  }
9604 
9605 
9606  protected:
9607  llrp_s32_t m_ZAxis;
9608 
9611  public:
9612  static const CFieldDescriptor
9613  s_fdZAxis;
9615 
9617  inline llrp_s32_t
9618  getZAxis (void)
9619  {
9620  return m_ZAxis;
9621  }
9622 
9624  inline void
9626  llrp_s32_t value)
9627  {
9628  m_ZAxis = value;
9629  }
9630 
9631 
9632 
9633  protected:
9634  std::list<CParameter *> m_listCustom;
9635 
9636  public:
9638  inline std::list<CParameter *>::iterator
9640  {
9641  return m_listCustom.begin();
9642  }
9643 
9645  inline std::list<CParameter *>::iterator
9646  endCustom (void)
9647  {
9648  return m_listCustom.end();
9649  }
9650 
9652  inline void
9654  {
9655  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9656  }
9657 
9659  inline int
9661  {
9662  return (int) (m_listCustom.size());
9663  }
9664 
9665  EResultCode
9667  addCustom (
9668  CParameter * pValue);
9669 
9670 
9671 };
9672 
9673 
9702 class CImpinjBeaconConfiguration : public CParameter
9703 {
9704  public:
9707 
9710 
9711  static const CFieldDescriptor * const
9712  s_apFieldDescriptorTable[];
9713 
9714  static const CTypeDescriptor
9715  s_typeDescriptor;
9716 
9717  void
9718  decodeFields (
9719  CDecoderStream * pDecoderStream);
9720 
9721  void
9722  assimilateSubParameters (
9723  CErrorDetails * pError);
9724 
9725  void
9726  encode (
9727  CEncoderStream * pEncoderStream) const;
9728 
9729 
9730  llrp_bool_t
9731  isAllowedIn (
9732  const CTypeDescriptor * pEnclosingElementType) const;
9733 
9734 
9735  static CElement *
9736  s_construct (void);
9737 
9738  static void
9739  s_decodeFields (
9740  CDecoderStream * pDecoderStream,
9741  CElement * pElement);
9743 
9744 
9745  protected:
9746  llrp_u1_t m_BeaconState;
9747 
9750  public:
9751  static const CFieldDescriptor
9752  s_fdBeaconState;
9754 
9756  inline llrp_u1_t
9758  {
9759  return m_BeaconState;
9760  }
9761 
9763  inline void
9765  llrp_u1_t value)
9766  {
9767  m_BeaconState = value;
9768  }
9769 
9770 
9771  protected:
9772  llrp_u64_t m_BeaconDurationSeconds;
9773 
9776  public:
9777  static const CFieldDescriptor
9778  s_fdBeaconDurationSeconds;
9780 
9782  inline llrp_u64_t
9784  {
9785  return m_BeaconDurationSeconds;
9786  }
9787 
9789  inline void
9791  llrp_u64_t value)
9792  {
9793  m_BeaconDurationSeconds = value;
9794  }
9795 
9796 
9797 
9798  protected:
9799  std::list<CParameter *> m_listCustom;
9800 
9801  public:
9803  inline std::list<CParameter *>::iterator
9805  {
9806  return m_listCustom.begin();
9807  }
9808 
9810  inline std::list<CParameter *>::iterator
9811  endCustom (void)
9812  {
9813  return m_listCustom.end();
9814  }
9815 
9817  inline void
9819  {
9820  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9821  }
9822 
9824  inline int
9826  {
9827  return (int) (m_listCustom.size());
9828  }
9829 
9830  EResultCode
9832  addCustom (
9833  CParameter * pValue);
9834 
9835 
9836 };
9837 
9838 
9866 class CImpinjAntennaConfiguration : public CParameter
9867 {
9868  public:
9871 
9874 
9875  static const CFieldDescriptor * const
9876  s_apFieldDescriptorTable[];
9877 
9878  static const CTypeDescriptor
9879  s_typeDescriptor;
9880 
9881  void
9882  decodeFields (
9883  CDecoderStream * pDecoderStream);
9884 
9885  void
9886  assimilateSubParameters (
9887  CErrorDetails * pError);
9888 
9889  void
9890  encode (
9891  CEncoderStream * pEncoderStream) const;
9892 
9893 
9894  llrp_bool_t
9895  isAllowedIn (
9896  const CTypeDescriptor * pEnclosingElementType) const;
9897 
9898 
9899  static CElement *
9900  s_construct (void);
9901 
9902  static void
9903  s_decodeFields (
9904  CDecoderStream * pDecoderStream,
9905  CElement * pElement);
9907 
9908 
9909 
9910  protected:
9911  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9912 
9913  public:
9917  {
9918  return m_pImpinjAntennaEventHysteresis;
9919  }
9920 
9922  EResultCode
9923  setImpinjAntennaEventHysteresis (
9925 
9926 
9927  protected:
9928  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9929 
9930  public:
9934  {
9935  return m_pImpinjAntennaEventConfiguration;
9936  }
9937 
9939  EResultCode
9940  setImpinjAntennaEventConfiguration (
9942 
9943 
9944  protected:
9945  std::list<CParameter *> m_listCustom;
9946 
9947  public:
9949  inline std::list<CParameter *>::iterator
9951  {
9952  return m_listCustom.begin();
9953  }
9954 
9956  inline std::list<CParameter *>::iterator
9957  endCustom (void)
9958  {
9959  return m_listCustom.end();
9960  }
9961 
9963  inline void
9965  {
9966  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9967  }
9968 
9970  inline int
9972  {
9973  return (int) (m_listCustom.size());
9974  }
9975 
9976  EResultCode
9978  addCustom (
9979  CParameter * pValue);
9980 
9981 
9982 };
9983 
9984 
10016 class CImpinjAntennaEventHysteresis : public CParameter
10017 {
10018  public:
10021 
10024 
10025  static const CFieldDescriptor * const
10026  s_apFieldDescriptorTable[];
10027 
10028  static const CTypeDescriptor
10029  s_typeDescriptor;
10030 
10031  void
10032  decodeFields (
10033  CDecoderStream * pDecoderStream);
10034 
10035  void
10036  assimilateSubParameters (
10037  CErrorDetails * pError);
10038 
10039  void
10040  encode (
10041  CEncoderStream * pEncoderStream) const;
10042 
10043 
10044  llrp_bool_t
10045  isAllowedIn (
10046  const CTypeDescriptor * pEnclosingElementType) const;
10047 
10048 
10049  static CElement *
10050  s_construct (void);
10051 
10052  static void
10053  s_decodeFields (
10054  CDecoderStream * pDecoderStream,
10055  CElement * pElement);
10057 
10058 
10059  protected:
10060  llrp_u64_t m_AntennaEventConnected;
10061 
10064  public:
10065  static const CFieldDescriptor
10066  s_fdAntennaEventConnected;
10068 
10070  inline llrp_u64_t
10072  {
10073  return m_AntennaEventConnected;
10074  }
10075 
10077  inline void
10079  llrp_u64_t value)
10080  {
10081  m_AntennaEventConnected = value;
10082  }
10083 
10084 
10085  protected:
10086  llrp_u64_t m_AntennaEventDisconnected;
10087 
10090  public:
10091  static const CFieldDescriptor
10092  s_fdAntennaEventDisconnected;
10094 
10096  inline llrp_u64_t
10098  {
10099  return m_AntennaEventDisconnected;
10100  }
10101 
10103  inline void
10105  llrp_u64_t value)
10106  {
10107  m_AntennaEventDisconnected = value;
10108  }
10109 
10110 
10111 
10112  protected:
10113  std::list<CParameter *> m_listCustom;
10114 
10115  public:
10117  inline std::list<CParameter *>::iterator
10119  {
10120  return m_listCustom.begin();
10121  }
10122 
10124  inline std::list<CParameter *>::iterator
10125  endCustom (void)
10126  {
10127  return m_listCustom.end();
10128  }
10129 
10131  inline void
10133  {
10134  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10135  }
10136 
10138  inline int
10140  {
10141  return (int) (m_listCustom.size());
10142  }
10143 
10144  EResultCode
10146  addCustom (
10147  CParameter * pValue);
10148 
10149 
10150 };
10151 
10152 
10178 class CImpinjAntennaEventConfiguration : public CParameter
10179 {
10180  public:
10183 
10186 
10187  static const CFieldDescriptor * const
10188  s_apFieldDescriptorTable[];
10189 
10190  static const CTypeDescriptor
10191  s_typeDescriptor;
10192 
10193  void
10194  decodeFields (
10195  CDecoderStream * pDecoderStream);
10196 
10197  void
10198  assimilateSubParameters (
10199  CErrorDetails * pError);
10200 
10201  void
10202  encode (
10203  CEncoderStream * pEncoderStream) const;
10204 
10205 
10206  llrp_bool_t
10207  isAllowedIn (
10208  const CTypeDescriptor * pEnclosingElementType) const;
10209 
10210 
10211  static CElement *
10212  s_construct (void);
10213 
10214  static void
10215  s_decodeFields (
10216  CDecoderStream * pDecoderStream,
10217  CElement * pElement);
10219 
10220 
10221  protected:
10222  llrp_u1_t m_EnableAntennaAttemptNotification;
10223 
10226  public:
10227  static const CFieldDescriptor
10228  s_fdEnableAntennaAttemptNotification;
10230 
10232  inline llrp_u1_t
10234  {
10235  return m_EnableAntennaAttemptNotification;
10236  }
10237 
10239  inline void
10241  llrp_u1_t value)
10242  {
10243  m_EnableAntennaAttemptNotification = value;
10244  }
10245 
10246 
10247 
10248  protected:
10249  std::list<CParameter *> m_listCustom;
10250 
10251  public:
10253  inline std::list<CParameter *>::iterator
10255  {
10256  return m_listCustom.begin();
10257  }
10258 
10260  inline std::list<CParameter *>::iterator
10261  endCustom (void)
10262  {
10263  return m_listCustom.end();
10264  }
10265 
10267  inline void
10269  {
10270  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10271  }
10272 
10274  inline int
10276  {
10277  return (int) (m_listCustom.size());
10278  }
10279 
10280  EResultCode
10282  addCustom (
10283  CParameter * pValue);
10284 
10285 
10286 };
10287 
10288 
10313 class CImpinjAntennaAttemptEvent : public CParameter
10314 {
10315  public:
10318 
10321 
10322  static const CFieldDescriptor * const
10323  s_apFieldDescriptorTable[];
10324 
10325  static const CTypeDescriptor
10326  s_typeDescriptor;
10327 
10328  void
10329  decodeFields (
10330  CDecoderStream * pDecoderStream);
10331 
10332  void
10333  assimilateSubParameters (
10334  CErrorDetails * pError);
10335 
10336  void
10337  encode (
10338  CEncoderStream * pEncoderStream) const;
10339 
10340 
10341  llrp_bool_t
10342  isAllowedIn (
10343  const CTypeDescriptor * pEnclosingElementType) const;
10344 
10345 
10346  static CElement *
10347  s_construct (void);
10348 
10349  static void
10350  s_decodeFields (
10351  CDecoderStream * pDecoderStream,
10352  CElement * pElement);
10354 
10355 
10356  protected:
10357  llrp_u16_t m_AntennaID;
10358 
10361  public:
10362  static const CFieldDescriptor
10363  s_fdAntennaID;
10365 
10367  inline llrp_u16_t
10369  {
10370  return m_AntennaID;
10371  }
10372 
10374  inline void
10376  llrp_u16_t value)
10377  {
10378  m_AntennaID = value;
10379  }
10380 
10381 
10382 
10383  protected:
10384  std::list<CParameter *> m_listCustom;
10385 
10386  public:
10388  inline std::list<CParameter *>::iterator
10390  {
10391  return m_listCustom.begin();
10392  }
10393 
10395  inline std::list<CParameter *>::iterator
10396  endCustom (void)
10397  {
10398  return m_listCustom.end();
10399  }
10400 
10402  inline void
10404  {
10405  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10406  }
10407 
10409  inline int
10411  {
10412  return (int) (m_listCustom.size());
10413  }
10414 
10415  EResultCode
10417  addCustom (
10418  CParameter * pValue);
10419 
10420 
10421 };
10422 
10423 
10451 class CImpinjHubConfiguration : public CParameter
10452 {
10453  public:
10454  CImpinjHubConfiguration (void);
10455  ~CImpinjHubConfiguration (void);
10456 
10459 
10460  static const CFieldDescriptor * const
10461  s_apFieldDescriptorTable[];
10462 
10463  static const CTypeDescriptor
10464  s_typeDescriptor;
10465 
10466  void
10467  decodeFields (
10468  CDecoderStream * pDecoderStream);
10469 
10470  void
10471  assimilateSubParameters (
10472  CErrorDetails * pError);
10473 
10474  void
10475  encode (
10476  CEncoderStream * pEncoderStream) const;
10477 
10478 
10479  llrp_bool_t
10480  isAllowedIn (
10481  const CTypeDescriptor * pEnclosingElementType) const;
10482 
10483 
10484  static CElement *
10485  s_construct (void);
10486 
10487  static void
10488  s_decodeFields (
10489  CDecoderStream * pDecoderStream,
10490  CElement * pElement);
10492 
10493 
10494  protected:
10495  llrp_u16_t m_HubID;
10496 
10499  public:
10500  static const CFieldDescriptor
10501  s_fdHubID;
10503 
10505  inline llrp_u16_t
10506  getHubID (void)
10507  {
10508  return m_HubID;
10509  }
10510 
10512  inline void
10514  llrp_u16_t value)
10515  {
10516  m_HubID = value;
10517  }
10518 
10519 
10520  protected:
10521  EImpinjHubConnectedType m_eConnected;
10522 
10525  public:
10526  static const CFieldDescriptor
10527  s_fdConnected;
10529 
10531  inline EImpinjHubConnectedType
10533  {
10534  return m_eConnected;
10535  }
10536 
10538  inline void
10540  EImpinjHubConnectedType value)
10541  {
10542  m_eConnected = value;
10543  }
10544 
10545 
10546  protected:
10547  EImpinjHubFaultType m_eFault;
10548 
10551  public:
10552  static const CFieldDescriptor
10553  s_fdFault;
10555 
10557  inline EImpinjHubFaultType
10558  getFault (void)
10559  {
10560  return m_eFault;
10561  }
10562 
10564  inline void
10566  EImpinjHubFaultType value)
10567  {
10568  m_eFault = value;
10569  }
10570 
10571 
10572 
10573  protected:
10574  std::list<CParameter *> m_listCustom;
10575 
10576  public:
10578  inline std::list<CParameter *>::iterator
10580  {
10581  return m_listCustom.begin();
10582  }
10583 
10585  inline std::list<CParameter *>::iterator
10586  endCustom (void)
10587  {
10588  return m_listCustom.end();
10589  }
10590 
10592  inline void
10594  {
10595  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10596  }
10597 
10599  inline int
10601  {
10602  return (int) (m_listCustom.size());
10603  }
10604 
10605  EResultCode
10607  addCustom (
10608  CParameter * pValue);
10609 
10610 
10611 };
10612 
10613 
10637 class CImpinjDiagnosticReport : public CParameter
10638 {
10639  public:
10640  CImpinjDiagnosticReport (void);
10641  ~CImpinjDiagnosticReport (void);
10642 
10645 
10646  static const CFieldDescriptor * const
10647  s_apFieldDescriptorTable[];
10648 
10649  static const CTypeDescriptor
10650  s_typeDescriptor;
10651 
10652  void
10653  decodeFields (
10654  CDecoderStream * pDecoderStream);
10655 
10656  void
10657  assimilateSubParameters (
10658  CErrorDetails * pError);
10659 
10660  void
10661  encode (
10662  CEncoderStream * pEncoderStream) const;
10663 
10664 
10665  llrp_bool_t
10666  isAllowedIn (
10667  const CTypeDescriptor * pEnclosingElementType) const;
10668 
10669 
10670  static CElement *
10671  s_construct (void);
10672 
10673  static void
10674  s_decodeFields (
10675  CDecoderStream * pDecoderStream,
10676  CElement * pElement);
10678 
10679 
10680  protected:
10681  llrp_u32v_t m_Metric;
10682 
10685  public:
10686  static const CFieldDescriptor
10687  s_fdMetric;
10689 
10691  inline llrp_u32v_t
10692  getMetric (void)
10693  {
10694  return m_Metric;
10695  }
10696 
10698  inline void
10700  llrp_u32v_t value)
10701  {
10702  m_Metric = value;
10703  }
10704 
10705 
10706 
10707 };
10708 
10709 
10748 class CImpinjPlacementConfiguration : public CParameter
10749 {
10750  public:
10753 
10756 
10757  static const CFieldDescriptor * const
10758  s_apFieldDescriptorTable[];
10759 
10760  static const CTypeDescriptor
10761  s_typeDescriptor;
10762 
10763  void
10764  decodeFields (
10765  CDecoderStream * pDecoderStream);
10766 
10767  void
10768  assimilateSubParameters (
10769  CErrorDetails * pError);
10770 
10771  void
10772  encode (
10773  CEncoderStream * pEncoderStream) const;
10774 
10775 
10776  llrp_bool_t
10777  isAllowedIn (
10778  const CTypeDescriptor * pEnclosingElementType) const;
10779 
10780 
10781  static CElement *
10782  s_construct (void);
10783 
10784  static void
10785  s_decodeFields (
10786  CDecoderStream * pDecoderStream,
10787  CElement * pElement);
10789 
10790 
10791  protected:
10792  llrp_u16_t m_HeightCm;
10793 
10796  public:
10797  static const CFieldDescriptor
10798  s_fdHeightCm;
10800 
10802  inline llrp_u16_t
10804  {
10805  return m_HeightCm;
10806  }
10807 
10809  inline void
10811  llrp_u16_t value)
10812  {
10813  m_HeightCm = value;
10814  }
10815 
10816 
10817  protected:
10818  llrp_s32_t m_FacilityXLocationCm;
10819 
10822  public:
10823  static const CFieldDescriptor
10824  s_fdFacilityXLocationCm;
10826 
10828  inline llrp_s32_t
10830  {
10831  return m_FacilityXLocationCm;
10832  }
10833 
10835  inline void
10837  llrp_s32_t value)
10838  {
10839  m_FacilityXLocationCm = value;
10840  }
10841 
10842 
10843  protected:
10844  llrp_s32_t m_FacilityYLocationCm;
10845 
10848  public:
10849  static const CFieldDescriptor
10850  s_fdFacilityYLocationCm;
10852 
10854  inline llrp_s32_t
10856  {
10857  return m_FacilityYLocationCm;
10858  }
10859 
10861  inline void
10863  llrp_s32_t value)
10864  {
10865  m_FacilityYLocationCm = value;
10866  }
10867 
10868 
10869  protected:
10870  llrp_s16_t m_OrientationDegrees;
10871 
10874  public:
10875  static const CFieldDescriptor
10876  s_fdOrientationDegrees;
10878 
10880  inline llrp_s16_t
10882  {
10883  return m_OrientationDegrees;
10884  }
10885 
10887  inline void
10889  llrp_s16_t value)
10890  {
10891  m_OrientationDegrees = value;
10892  }
10893 
10894 
10895 
10896  protected:
10897  std::list<CParameter *> m_listCustom;
10898 
10899  public:
10901  inline std::list<CParameter *>::iterator
10903  {
10904  return m_listCustom.begin();
10905  }
10906 
10908  inline std::list<CParameter *>::iterator
10909  endCustom (void)
10910  {
10911  return m_listCustom.end();
10912  }
10913 
10915  inline void
10917  {
10918  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10919  }
10920 
10922  inline int
10924  {
10925  return (int) (m_listCustom.size());
10926  }
10927 
10928  EResultCode
10930  addCustom (
10931  CParameter * pValue);
10932 
10933 
10934 };
10935 
10936 
10967 class CImpinjLISpec : public CParameter
10968 {
10969  public:
10970  CImpinjLISpec (void);
10971  ~CImpinjLISpec (void);
10972 
10975 
10976  static const CFieldDescriptor * const
10977  s_apFieldDescriptorTable[];
10978 
10979  static const CTypeDescriptor
10980  s_typeDescriptor;
10981 
10982  void
10983  decodeFields (
10984  CDecoderStream * pDecoderStream);
10985 
10986  void
10987  assimilateSubParameters (
10988  CErrorDetails * pError);
10989 
10990  void
10991  encode (
10992  CEncoderStream * pEncoderStream) const;
10993 
10994 
10995  llrp_bool_t
10996  isAllowedIn (
10997  const CTypeDescriptor * pEnclosingElementType) const;
10998 
10999 
11000  static CElement *
11001  s_construct (void);
11002 
11003  static void
11004  s_decodeFields (
11005  CDecoderStream * pDecoderStream,
11006  CElement * pElement);
11008 
11009 
11010 
11011  protected:
11012  CImpinjLocationConfig * m_pImpinjLocationConfig;
11013 
11014  public:
11016  inline CImpinjLocationConfig *
11018  {
11019  return m_pImpinjLocationConfig;
11020  }
11021 
11023  EResultCode
11024  setImpinjLocationConfig (
11025  CImpinjLocationConfig * pValue);
11026 
11027 
11028  protected:
11029  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
11030 
11031  public:
11033  inline CImpinjC1G2LocationConfig *
11035  {
11036  return m_pImpinjC1G2LocationConfig;
11037  }
11038 
11040  EResultCode
11041  setImpinjC1G2LocationConfig (
11042  CImpinjC1G2LocationConfig * pValue);
11043 
11044 
11045  protected:
11046  CImpinjLocationReporting * m_pImpinjLocationReporting;
11047 
11048  public:
11050  inline CImpinjLocationReporting *
11052  {
11053  return m_pImpinjLocationReporting;
11054  }
11055 
11057  EResultCode
11058  setImpinjLocationReporting (
11059  CImpinjLocationReporting * pValue);
11060 
11061 
11062  protected:
11063  std::list<CParameter *> m_listCustom;
11064 
11065  public:
11067  inline std::list<CParameter *>::iterator
11069  {
11070  return m_listCustom.begin();
11071  }
11072 
11074  inline std::list<CParameter *>::iterator
11075  endCustom (void)
11076  {
11077  return m_listCustom.end();
11078  }
11079 
11081  inline void
11083  {
11084  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11085  }
11086 
11088  inline int
11090  {
11091  return (int) (m_listCustom.size());
11092  }
11093 
11094  EResultCode
11096  addCustom (
11097  CParameter * pValue);
11098 
11099 
11100 };
11101 
11102 
11148 class CImpinjLocationConfig : public CParameter
11149 {
11150  public:
11151  CImpinjLocationConfig (void);
11152  ~CImpinjLocationConfig (void);
11153 
11156 
11157  static const CFieldDescriptor * const
11158  s_apFieldDescriptorTable[];
11159 
11160  static const CTypeDescriptor
11161  s_typeDescriptor;
11162 
11163  void
11164  decodeFields (
11165  CDecoderStream * pDecoderStream);
11166 
11167  void
11168  assimilateSubParameters (
11169  CErrorDetails * pError);
11170 
11171  void
11172  encode (
11173  CEncoderStream * pEncoderStream) const;
11174 
11175 
11176  llrp_bool_t
11177  isAllowedIn (
11178  const CTypeDescriptor * pEnclosingElementType) const;
11179 
11180 
11181  static CElement *
11182  s_construct (void);
11183 
11184  static void
11185  s_decodeFields (
11186  CDecoderStream * pDecoderStream,
11187  CElement * pElement);
11189 
11190 
11191  protected:
11192  llrp_u16_t m_ComputeWindowSeconds;
11193 
11196  public:
11197  static const CFieldDescriptor
11198  s_fdComputeWindowSeconds;
11200 
11202  inline llrp_u16_t
11204  {
11205  return m_ComputeWindowSeconds;
11206  }
11207 
11209  inline void
11211  llrp_u16_t value)
11212  {
11213  m_ComputeWindowSeconds = value;
11214  }
11215 
11216 
11217  protected:
11218  llrp_u16_t m_TagAgeIntervalSeconds;
11219 
11222  public:
11223  static const CFieldDescriptor
11224  s_fdTagAgeIntervalSeconds;
11226 
11228  inline llrp_u16_t
11230  {
11231  return m_TagAgeIntervalSeconds;
11232  }
11233 
11235  inline void
11237  llrp_u16_t value)
11238  {
11239  m_TagAgeIntervalSeconds = value;
11240  }
11241 
11242 
11243  protected:
11244  llrp_u16_t m_UpdateIntervalSeconds;
11245 
11248  public:
11249  static const CFieldDescriptor
11250  s_fdUpdateIntervalSeconds;
11252 
11254  inline llrp_u16_t
11256  {
11257  return m_UpdateIntervalSeconds;
11258  }
11259 
11261  inline void
11263  llrp_u16_t value)
11264  {
11265  m_UpdateIntervalSeconds = value;
11266  }
11267 
11268 
11269 
11270  protected:
11271  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
11272 
11273  public:
11275  inline CImpinjDisabledAntennas *
11277  {
11278  return m_pImpinjDisabledAntennas;
11279  }
11280 
11282  EResultCode
11283  setImpinjDisabledAntennas (
11284  CImpinjDisabledAntennas * pValue);
11285 
11286 
11287  protected:
11288  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
11289 
11290  public:
11294  {
11295  return m_pImpinjLocationAlgorithmControl;
11296  }
11297 
11299  EResultCode
11300  setImpinjLocationAlgorithmControl (
11302 
11303 
11304  protected:
11305  std::list<CParameter *> m_listCustom;
11306 
11307  public:
11309  inline std::list<CParameter *>::iterator
11311  {
11312  return m_listCustom.begin();
11313  }
11314 
11316  inline std::list<CParameter *>::iterator
11317  endCustom (void)
11318  {
11319  return m_listCustom.end();
11320  }
11321 
11323  inline void
11325  {
11326  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11327  }
11328 
11330  inline int
11332  {
11333  return (int) (m_listCustom.size());
11334  }
11335 
11336  EResultCode
11338  addCustom (
11339  CParameter * pValue);
11340 
11341 
11342 };
11343 
11344 
11387 class CImpinjC1G2LocationConfig : public CParameter
11388 {
11389  public:
11391  ~CImpinjC1G2LocationConfig (void);
11392 
11395 
11396  static const CFieldDescriptor * const
11397  s_apFieldDescriptorTable[];
11398 
11399  static const CTypeDescriptor
11400  s_typeDescriptor;
11401 
11402  void
11403  decodeFields (
11404  CDecoderStream * pDecoderStream);
11405 
11406  void
11407  assimilateSubParameters (
11408  CErrorDetails * pError);
11409 
11410  void
11411  encode (
11412  CEncoderStream * pEncoderStream) const;
11413 
11414 
11415  llrp_bool_t
11416  isAllowedIn (
11417  const CTypeDescriptor * pEnclosingElementType) const;
11418 
11419 
11420  static CElement *
11421  s_construct (void);
11422 
11423  static void
11424  s_decodeFields (
11425  CDecoderStream * pDecoderStream,
11426  CElement * pElement);
11428 
11429 
11430  protected:
11431  llrp_u16_t m_ModeIndex;
11432 
11435  public:
11436  static const CFieldDescriptor
11437  s_fdModeIndex;
11439 
11441  inline llrp_u16_t
11443  {
11444  return m_ModeIndex;
11445  }
11446 
11448  inline void
11450  llrp_u16_t value)
11451  {
11452  m_ModeIndex = value;
11453  }
11454 
11455 
11456  protected:
11457  llrp_u2_t m_Session;
11458 
11461  public:
11462  static const CFieldDescriptor
11463  s_fdSession;
11465 
11467  inline llrp_u2_t
11468  getSession (void)
11469  {
11470  return m_Session;
11471  }
11472 
11474  inline void
11476  llrp_u2_t value)
11477  {
11478  m_Session = value;
11479  }
11480 
11481 
11482 
11483  protected:
11484  std::list<CC1G2Filter *> m_listC1G2Filter;
11485 
11486  public:
11488  inline std::list<CC1G2Filter *>::iterator
11490  {
11491  return m_listC1G2Filter.begin();
11492  }
11493 
11495  inline std::list<CC1G2Filter *>::iterator
11497  {
11498  return m_listC1G2Filter.end();
11499  }
11500 
11502  inline void
11504  {
11505  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
11506  }
11507 
11509  inline int
11511  {
11512  return (int) (m_listC1G2Filter.size());
11513  }
11514 
11515  EResultCode
11517  addC1G2Filter (
11518  CC1G2Filter * pValue);
11519 
11520 
11521  protected:
11522  CImpinjTransmitPower * m_pImpinjTransmitPower;
11523 
11524  public:
11526  inline CImpinjTransmitPower *
11528  {
11529  return m_pImpinjTransmitPower;
11530  }
11531 
11533  EResultCode
11534  setImpinjTransmitPower (
11535  CImpinjTransmitPower * pValue);
11536 
11537 
11538  protected:
11539  std::list<CParameter *> m_listCustom;
11540 
11541  public:
11543  inline std::list<CParameter *>::iterator
11545  {
11546  return m_listCustom.begin();
11547  }
11548 
11550  inline std::list<CParameter *>::iterator
11551  endCustom (void)
11552  {
11553  return m_listCustom.end();
11554  }
11555 
11557  inline void
11559  {
11560  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11561  }
11562 
11564  inline int
11566  {
11567  return (int) (m_listCustom.size());
11568  }
11569 
11570  EResultCode
11572  addCustom (
11573  CParameter * pValue);
11574 
11575 
11576 };
11577 
11578 
11620 class CImpinjLocationReporting : public CParameter
11621 {
11622  public:
11623  CImpinjLocationReporting (void);
11624  ~CImpinjLocationReporting (void);
11625 
11628 
11629  static const CFieldDescriptor * const
11630  s_apFieldDescriptorTable[];
11631 
11632  static const CTypeDescriptor
11633  s_typeDescriptor;
11634 
11635  void
11636  decodeFields (
11637  CDecoderStream * pDecoderStream);
11638 
11639  void
11640  assimilateSubParameters (
11641  CErrorDetails * pError);
11642 
11643  void
11644  encode (
11645  CEncoderStream * pEncoderStream) const;
11646 
11647 
11648  llrp_bool_t
11649  isAllowedIn (
11650  const CTypeDescriptor * pEnclosingElementType) const;
11651 
11652 
11653  static CElement *
11654  s_construct (void);
11655 
11656  static void
11657  s_decodeFields (
11658  CDecoderStream * pDecoderStream,
11659  CElement * pElement);
11661 
11662 
11663  protected:
11664  llrp_u1_t m_EnableUpdateReport;
11665 
11668  public:
11669  static const CFieldDescriptor
11670  s_fdEnableUpdateReport;
11672 
11674  inline llrp_u1_t
11676  {
11677  return m_EnableUpdateReport;
11678  }
11679 
11681  inline void
11683  llrp_u1_t value)
11684  {
11685  m_EnableUpdateReport = value;
11686  }
11687 
11688 
11689  protected:
11690  llrp_u1_t m_EnableEntryReport;
11691 
11694  public:
11695  static const CFieldDescriptor
11696  s_fdEnableEntryReport;
11698 
11700  inline llrp_u1_t
11702  {
11703  return m_EnableEntryReport;
11704  }
11705 
11707  inline void
11709  llrp_u1_t value)
11710  {
11711  m_EnableEntryReport = value;
11712  }
11713 
11714 
11715  protected:
11716  llrp_u1_t m_EnableExitReport;
11717 
11720  public:
11721  static const CFieldDescriptor
11722  s_fdEnableExitReport;
11724 
11726  inline llrp_u1_t
11728  {
11729  return m_EnableExitReport;
11730  }
11731 
11733  inline void
11735  llrp_u1_t value)
11736  {
11737  m_EnableExitReport = value;
11738  }
11739 
11740 
11741  protected:
11742  llrp_u1_t m_EnableDiagnosticReport;
11743 
11746  public:
11747  static const CFieldDescriptor
11748  s_fdEnableDiagnosticReport;
11750 
11752  inline llrp_u1_t
11754  {
11755  return m_EnableDiagnosticReport;
11756  }
11757 
11759  inline void
11761  llrp_u1_t value)
11762  {
11763  m_EnableDiagnosticReport = value;
11764  }
11765 
11766 
11767 
11768  protected:
11769  std::list<CParameter *> m_listCustom;
11770 
11771  public:
11773  inline std::list<CParameter *>::iterator
11775  {
11776  return m_listCustom.begin();
11777  }
11778 
11780  inline std::list<CParameter *>::iterator
11781  endCustom (void)
11782  {
11783  return m_listCustom.end();
11784  }
11785 
11787  inline void
11789  {
11790  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11791  }
11792 
11794  inline int
11796  {
11797  return (int) (m_listCustom.size());
11798  }
11799 
11800  EResultCode
11802  addCustom (
11803  CParameter * pValue);
11804 
11805 
11806 };
11807 
11808 
11839 class CImpinjLocationConfidence : public CParameter
11840 {
11841  public:
11843  ~CImpinjLocationConfidence (void);
11844 
11847 
11848  static const CFieldDescriptor * const
11849  s_apFieldDescriptorTable[];
11850 
11851  static const CTypeDescriptor
11852  s_typeDescriptor;
11853 
11854  void
11855  decodeFields (
11856  CDecoderStream * pDecoderStream);
11857 
11858  void
11859  assimilateSubParameters (
11860  CErrorDetails * pError);
11861 
11862  void
11863  encode (
11864  CEncoderStream * pEncoderStream) const;
11865 
11866 
11867  llrp_bool_t
11868  isAllowedIn (
11869  const CTypeDescriptor * pEnclosingElementType) const;
11870 
11871 
11872  static CElement *
11873  s_construct (void);
11874 
11875  static void
11876  s_decodeFields (
11877  CDecoderStream * pDecoderStream,
11878  CElement * pElement);
11880 
11881 
11882  protected:
11883  llrp_u16_t m_ReadCount;
11884 
11887  public:
11888  static const CFieldDescriptor
11889  s_fdReadCount;
11891 
11893  inline llrp_u16_t
11895  {
11896  return m_ReadCount;
11897  }
11898 
11900  inline void
11902  llrp_u16_t value)
11903  {
11904  m_ReadCount = value;
11905  }
11906 
11907 
11908  protected:
11909  llrp_u32v_t m_ConfidenceData;
11910 
11913  public:
11914  static const CFieldDescriptor
11915  s_fdConfidenceData;
11917 
11919  inline llrp_u32v_t
11921  {
11922  return m_ConfidenceData;
11923  }
11924 
11926  inline void
11928  llrp_u32v_t value)
11929  {
11930  m_ConfidenceData = value;
11931  }
11932 
11933 
11934 
11935  protected:
11936  std::list<CParameter *> m_listCustom;
11937 
11938  public:
11940  inline std::list<CParameter *>::iterator
11942  {
11943  return m_listCustom.begin();
11944  }
11945 
11947  inline std::list<CParameter *>::iterator
11948  endCustom (void)
11949  {
11950  return m_listCustom.end();
11951  }
11952 
11954  inline void
11956  {
11957  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11958  }
11959 
11961  inline int
11963  {
11964  return (int) (m_listCustom.size());
11965  }
11966 
11967  EResultCode
11969  addCustom (
11970  CParameter * pValue);
11971 
11972 
11973 };
11974 
11975 
12013 class CImpinjLocationReportData : public CParameter
12014 {
12015  public:
12017  ~CImpinjLocationReportData (void);
12018 
12021 
12022  static const CFieldDescriptor * const
12023  s_apFieldDescriptorTable[];
12024 
12025  static const CTypeDescriptor
12026  s_typeDescriptor;
12027 
12028  void
12029  decodeFields (
12030  CDecoderStream * pDecoderStream);
12031 
12032  void
12033  assimilateSubParameters (
12034  CErrorDetails * pError);
12035 
12036  void
12037  encode (
12038  CEncoderStream * pEncoderStream) const;
12039 
12040 
12041  llrp_bool_t
12042  isAllowedIn (
12043  const CTypeDescriptor * pEnclosingElementType) const;
12044 
12045 
12046  static CElement *
12047  s_construct (void);
12048 
12049  static void
12050  s_decodeFields (
12051  CDecoderStream * pDecoderStream,
12052  CElement * pElement);
12054 
12055 
12056  protected:
12057  llrp_u64_t m_LastSeenTimestampUTC;
12058 
12061  public:
12062  static const CFieldDescriptor
12063  s_fdLastSeenTimestampUTC;
12065 
12067  inline llrp_u64_t
12069  {
12070  return m_LastSeenTimestampUTC;
12071  }
12072 
12074  inline void
12076  llrp_u64_t value)
12077  {
12078  m_LastSeenTimestampUTC = value;
12079  }
12080 
12081 
12082  protected:
12083  llrp_s32_t m_LocXCentimeters;
12084 
12087  public:
12088  static const CFieldDescriptor
12089  s_fdLocXCentimeters;
12091 
12093  inline llrp_s32_t
12095  {
12096  return m_LocXCentimeters;
12097  }
12098 
12100  inline void
12102  llrp_s32_t value)
12103  {
12104  m_LocXCentimeters = value;
12105  }
12106 
12107 
12108  protected:
12109  llrp_s32_t m_LocYCentimeters;
12110 
12113  public:
12114  static const CFieldDescriptor
12115  s_fdLocYCentimeters;
12117 
12119  inline llrp_s32_t
12121  {
12122  return m_LocYCentimeters;
12123  }
12124 
12126  inline void
12128  llrp_s32_t value)
12129  {
12130  m_LocYCentimeters = value;
12131  }
12132 
12133 
12134  protected:
12135  EImpinjLocationReportType m_eType;
12136 
12139  public:
12140  static const CFieldDescriptor
12141  s_fdType;
12143 
12145  inline EImpinjLocationReportType
12146  getType (void)
12147  {
12148  return m_eType;
12149  }
12150 
12152  inline void
12154  EImpinjLocationReportType value)
12155  {
12156  m_eType = value;
12157  }
12158 
12159 
12160 
12161  protected:
12162  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
12163 
12164  public:
12166  inline CImpinjLocationConfidence *
12168  {
12169  return m_pImpinjLocationConfidence;
12170  }
12171 
12173  EResultCode
12174  setImpinjLocationConfidence (
12175  CImpinjLocationConfidence * pValue);
12176 
12177 
12178  protected:
12179  std::list<CParameter *> m_listCustom;
12180 
12181  public:
12183  inline std::list<CParameter *>::iterator
12185  {
12186  return m_listCustom.begin();
12187  }
12188 
12190  inline std::list<CParameter *>::iterator
12191  endCustom (void)
12192  {
12193  return m_listCustom.end();
12194  }
12195 
12197  inline void
12199  {
12200  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12201  }
12202 
12204  inline int
12206  {
12207  return (int) (m_listCustom.size());
12208  }
12209 
12210  EResultCode
12212  addCustom (
12213  CParameter * pValue);
12214 
12215 
12216 };
12217 
12218 
12251 class CImpinjDISpec : public CParameter
12252 {
12253  public:
12254  CImpinjDISpec (void);
12255  ~CImpinjDISpec (void);
12256 
12259 
12260  static const CFieldDescriptor * const
12261  s_apFieldDescriptorTable[];
12262 
12263  static const CTypeDescriptor
12264  s_typeDescriptor;
12265 
12266  void
12267  decodeFields (
12268  CDecoderStream * pDecoderStream);
12269 
12270  void
12271  assimilateSubParameters (
12272  CErrorDetails * pError);
12273 
12274  void
12275  encode (
12276  CEncoderStream * pEncoderStream) const;
12277 
12278 
12279  llrp_bool_t
12280  isAllowedIn (
12281  const CTypeDescriptor * pEnclosingElementType) const;
12282 
12283 
12284  static CElement *
12285  s_construct (void);
12286 
12287  static void
12288  s_decodeFields (
12289  CDecoderStream * pDecoderStream,
12290  CElement * pElement);
12292 
12293 
12294 
12295  protected:
12296  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
12297 
12298  public:
12300  inline CImpinjDirectionSectors *
12302  {
12303  return m_pImpinjDirectionSectors;
12304  }
12305 
12307  EResultCode
12308  setImpinjDirectionSectors (
12309  CImpinjDirectionSectors * pValue);
12310 
12311 
12312  protected:
12313  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
12314 
12315  public:
12317  inline CImpinjDirectionConfig *
12319  {
12320  return m_pImpinjDirectionConfig;
12321  }
12322 
12324  EResultCode
12325  setImpinjDirectionConfig (
12326  CImpinjDirectionConfig * pValue);
12327 
12328 
12329  protected:
12330  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
12331 
12332  public:
12336  {
12337  return m_pImpinjC1G2DirectionConfig;
12338  }
12339 
12341  EResultCode
12342  setImpinjC1G2DirectionConfig (
12343  CImpinjC1G2DirectionConfig * pValue);
12344 
12345 
12346  protected:
12347  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
12348 
12349  public:
12351  inline CImpinjDirectionReporting *
12353  {
12354  return m_pImpinjDirectionReporting;
12355  }
12356 
12358  EResultCode
12359  setImpinjDirectionReporting (
12360  CImpinjDirectionReporting * pValue);
12361 
12362 
12363  protected:
12364  std::list<CParameter *> m_listCustom;
12365 
12366  public:
12368  inline std::list<CParameter *>::iterator
12370  {
12371  return m_listCustom.begin();
12372  }
12373 
12375  inline std::list<CParameter *>::iterator
12376  endCustom (void)
12377  {
12378  return m_listCustom.end();
12379  }
12380 
12382  inline void
12384  {
12385  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12386  }
12387 
12389  inline int
12391  {
12392  return (int) (m_listCustom.size());
12393  }
12394 
12395  EResultCode
12397  addCustom (
12398  CParameter * pValue);
12399 
12400 
12401 };
12402 
12403 
12431 class CImpinjDirectionSectors : public CParameter
12432 {
12433  public:
12434  CImpinjDirectionSectors (void);
12435  ~CImpinjDirectionSectors (void);
12436 
12439 
12440  static const CFieldDescriptor * const
12441  s_apFieldDescriptorTable[];
12442 
12443  static const CTypeDescriptor
12444  s_typeDescriptor;
12445 
12446  void
12447  decodeFields (
12448  CDecoderStream * pDecoderStream);
12449 
12450  void
12451  assimilateSubParameters (
12452  CErrorDetails * pError);
12453 
12454  void
12455  encode (
12456  CEncoderStream * pEncoderStream) const;
12457 
12458 
12459  llrp_bool_t
12460  isAllowedIn (
12461  const CTypeDescriptor * pEnclosingElementType) const;
12462 
12463 
12464  static CElement *
12465  s_construct (void);
12466 
12467  static void
12468  s_decodeFields (
12469  CDecoderStream * pDecoderStream,
12470  CElement * pElement);
12472 
12473 
12474  protected:
12475  llrp_u16v_t m_EnabledSectorIDs;
12476 
12479  public:
12480  static const CFieldDescriptor
12481  s_fdEnabledSectorIDs;
12483 
12485  inline llrp_u16v_t
12487  {
12488  return m_EnabledSectorIDs;
12489  }
12490 
12492  inline void
12494  llrp_u16v_t value)
12495  {
12496  m_EnabledSectorIDs = value;
12497  }
12498 
12499 
12500 
12501  protected:
12502  std::list<CParameter *> m_listCustom;
12503 
12504  public:
12506  inline std::list<CParameter *>::iterator
12508  {
12509  return m_listCustom.begin();
12510  }
12511 
12513  inline std::list<CParameter *>::iterator
12514  endCustom (void)
12515  {
12516  return m_listCustom.end();
12517  }
12518 
12520  inline void
12522  {
12523  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12524  }
12525 
12527  inline int
12529  {
12530  return (int) (m_listCustom.size());
12531  }
12532 
12533  EResultCode
12535  addCustom (
12536  CParameter * pValue);
12537 
12538 
12539 };
12540 
12541 
12580 class CImpinjDirectionConfig : public CParameter
12581 {
12582  public:
12583  CImpinjDirectionConfig (void);
12584  ~CImpinjDirectionConfig (void);
12585 
12588 
12589  static const CFieldDescriptor * const
12590  s_apFieldDescriptorTable[];
12591 
12592  static const CTypeDescriptor
12593  s_typeDescriptor;
12594 
12595  void
12596  decodeFields (
12597  CDecoderStream * pDecoderStream);
12598 
12599  void
12600  assimilateSubParameters (
12601  CErrorDetails * pError);
12602 
12603  void
12604  encode (
12605  CEncoderStream * pEncoderStream) const;
12606 
12607 
12608  llrp_bool_t
12609  isAllowedIn (
12610  const CTypeDescriptor * pEnclosingElementType) const;
12611 
12612 
12613  static CElement *
12614  s_construct (void);
12615 
12616  static void
12617  s_decodeFields (
12618  CDecoderStream * pDecoderStream,
12619  CElement * pElement);
12621 
12622 
12623  protected:
12624  llrp_u16_t m_TagAgeIntervalSeconds;
12625 
12628  public:
12629  static const CFieldDescriptor
12630  s_fdTagAgeIntervalSeconds;
12632 
12634  inline llrp_u16_t
12636  {
12637  return m_TagAgeIntervalSeconds;
12638  }
12639 
12641  inline void
12643  llrp_u16_t value)
12644  {
12645  m_TagAgeIntervalSeconds = value;
12646  }
12647 
12648 
12649  protected:
12650  llrp_u16_t m_UpdateIntervalSeconds;
12651 
12654  public:
12655  static const CFieldDescriptor
12656  s_fdUpdateIntervalSeconds;
12658 
12660  inline llrp_u16_t
12662  {
12663  return m_UpdateIntervalSeconds;
12664  }
12665 
12667  inline void
12669  llrp_u16_t value)
12670  {
12671  m_UpdateIntervalSeconds = value;
12672  }
12673 
12674 
12675  protected:
12676  EImpinjDirectionFieldOfView m_eFieldOfView;
12677 
12680  public:
12681  static const CFieldDescriptor
12682  s_fdFieldOfView;
12684 
12686  inline EImpinjDirectionFieldOfView
12688  {
12689  return m_eFieldOfView;
12690  }
12691 
12693  inline void
12695  EImpinjDirectionFieldOfView value)
12696  {
12697  m_eFieldOfView = value;
12698  }
12699 
12700 
12701 
12702  protected:
12703  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12704 
12705  public:
12709  {
12710  return m_pImpinjDirectionUserTagPopulationLimit;
12711  }
12712 
12714  EResultCode
12715  setImpinjDirectionUserTagPopulationLimit (
12717 
12718 
12719  protected:
12720  std::list<CParameter *> m_listCustom;
12721 
12722  public:
12724  inline std::list<CParameter *>::iterator
12726  {
12727  return m_listCustom.begin();
12728  }
12729 
12731  inline std::list<CParameter *>::iterator
12732  endCustom (void)
12733  {
12734  return m_listCustom.end();
12735  }
12736 
12738  inline void
12740  {
12741  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12742  }
12743 
12745  inline int
12747  {
12748  return (int) (m_listCustom.size());
12749  }
12750 
12751  EResultCode
12753  addCustom (
12754  CParameter * pValue);
12755 
12756 
12757 };
12758 
12759 
12782 class CImpinjDirectionUserTagPopulationLimit : public CParameter
12783 {
12784  public:
12787 
12790 
12791  static const CFieldDescriptor * const
12792  s_apFieldDescriptorTable[];
12793 
12794  static const CTypeDescriptor
12795  s_typeDescriptor;
12796 
12797  void
12798  decodeFields (
12799  CDecoderStream * pDecoderStream);
12800 
12801  void
12802  assimilateSubParameters (
12803  CErrorDetails * pError);
12804 
12805  void
12806  encode (
12807  CEncoderStream * pEncoderStream) const;
12808 
12809 
12810  llrp_bool_t
12811  isAllowedIn (
12812  const CTypeDescriptor * pEnclosingElementType) const;
12813 
12814 
12815  static CElement *
12816  s_construct (void);
12817 
12818  static void
12819  s_decodeFields (
12820  CDecoderStream * pDecoderStream,
12821  CElement * pElement);
12823 
12824 
12825  protected:
12826  llrp_u16_t m_UserTagPopulationLimit;
12827 
12830  public:
12831  static const CFieldDescriptor
12832  s_fdUserTagPopulationLimit;
12834 
12836  inline llrp_u16_t
12838  {
12839  return m_UserTagPopulationLimit;
12840  }
12841 
12843  inline void
12845  llrp_u16_t value)
12846  {
12847  m_UserTagPopulationLimit = value;
12848  }
12849 
12850 
12851 
12852 };
12853 
12854 
12892 class CImpinjC1G2DirectionConfig : public CParameter
12893 {
12894  public:
12897 
12900 
12901  static const CFieldDescriptor * const
12902  s_apFieldDescriptorTable[];
12903 
12904  static const CTypeDescriptor
12905  s_typeDescriptor;
12906 
12907  void
12908  decodeFields (
12909  CDecoderStream * pDecoderStream);
12910 
12911  void
12912  assimilateSubParameters (
12913  CErrorDetails * pError);
12914 
12915  void
12916  encode (
12917  CEncoderStream * pEncoderStream) const;
12918 
12919 
12920  llrp_bool_t
12921  isAllowedIn (
12922  const CTypeDescriptor * pEnclosingElementType) const;
12923 
12924 
12925  static CElement *
12926  s_construct (void);
12927 
12928  static void
12929  s_decodeFields (
12930  CDecoderStream * pDecoderStream,
12931  CElement * pElement);
12933 
12934 
12935  protected:
12936  EImpinjDirectionRFMode m_eRFMode;
12937 
12940  public:
12941  static const CFieldDescriptor
12942  s_fdRFMode;
12944 
12946  inline EImpinjDirectionRFMode
12947  getRFMode (void)
12948  {
12949  return m_eRFMode;
12950  }
12951 
12953  inline void
12955  EImpinjDirectionRFMode value)
12956  {
12957  m_eRFMode = value;
12958  }
12959 
12960 
12961 
12962  protected:
12963  CImpinjTransmitPower * m_pImpinjTransmitPower;
12964 
12965  public:
12967  inline CImpinjTransmitPower *
12969  {
12970  return m_pImpinjTransmitPower;
12971  }
12972 
12974  EResultCode
12975  setImpinjTransmitPower (
12976  CImpinjTransmitPower * pValue);
12977 
12978 
12979  protected:
12980  std::list<CC1G2Filter *> m_listC1G2Filter;
12981 
12982  public:
12984  inline std::list<CC1G2Filter *>::iterator
12986  {
12987  return m_listC1G2Filter.begin();
12988  }
12989 
12991  inline std::list<CC1G2Filter *>::iterator
12993  {
12994  return m_listC1G2Filter.end();
12995  }
12996 
12998  inline void
13000  {
13001  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
13002  }
13003 
13005  inline int
13007  {
13008  return (int) (m_listC1G2Filter.size());
13009  }
13010 
13011  EResultCode
13013  addC1G2Filter (
13014  CC1G2Filter * pValue);
13015 
13016 
13017  protected:
13018  std::list<CParameter *> m_listCustom;
13019 
13020  public:
13022  inline std::list<CParameter *>::iterator
13024  {
13025  return m_listCustom.begin();
13026  }
13027 
13029  inline std::list<CParameter *>::iterator
13030  endCustom (void)
13031  {
13032  return m_listCustom.end();
13033  }
13034 
13036  inline void
13038  {
13039  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13040  }
13041 
13043  inline int
13045  {
13046  return (int) (m_listCustom.size());
13047  }
13048 
13049  EResultCode
13051  addCustom (
13052  CParameter * pValue);
13053 
13054 
13055 };
13056 
13057 
13090 class CImpinjExtendedTagInformation : public CParameter
13091 {
13092  public:
13095 
13098 
13099  static const CFieldDescriptor * const
13100  s_apFieldDescriptorTable[];
13101 
13102  static const CTypeDescriptor
13103  s_typeDescriptor;
13104 
13105  void
13106  decodeFields (
13107  CDecoderStream * pDecoderStream);
13108 
13109  void
13110  assimilateSubParameters (
13111  CErrorDetails * pError);
13112 
13113  void
13114  encode (
13115  CEncoderStream * pEncoderStream) const;
13116 
13117 
13118  llrp_bool_t
13119  isAllowedIn (
13120  const CTypeDescriptor * pEnclosingElementType) const;
13121 
13122 
13123  static CElement *
13124  s_construct (void);
13125 
13126  static void
13127  s_decodeFields (
13128  CDecoderStream * pDecoderStream,
13129  CElement * pElement);
13131 
13132 
13133 
13134  protected:
13135  std::list<CEPCData *> m_listEPCData;
13136 
13137  public:
13139  inline std::list<CEPCData *>::iterator
13141  {
13142  return m_listEPCData.begin();
13143  }
13144 
13146  inline std::list<CEPCData *>::iterator
13147  endEPCData (void)
13148  {
13149  return m_listEPCData.end();
13150  }
13151 
13153  inline void
13155  {
13156  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
13157  }
13158 
13160  inline int
13162  {
13163  return (int) (m_listEPCData.size());
13164  }
13165 
13166  EResultCode
13168  addEPCData (
13169  CEPCData * pValue);
13170 
13171 
13172  protected:
13173  CImpinjLocationReportData * m_pImpinjLocationReportData;
13174 
13175  public:
13177  inline CImpinjLocationReportData *
13179  {
13180  return m_pImpinjLocationReportData;
13181  }
13182 
13184  EResultCode
13185  setImpinjLocationReportData (
13186  CImpinjLocationReportData * pValue);
13187 
13188 
13189  protected:
13190  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
13191 
13192  public:
13196  {
13197  return m_pImpinjDirectionReportData;
13198  }
13199 
13201  EResultCode
13202  setImpinjDirectionReportData (
13203  CImpinjDirectionReportData * pValue);
13204 
13205 
13206  protected:
13207  std::list<CParameter *> m_listCustom;
13208 
13209  public:
13211  inline std::list<CParameter *>::iterator
13213  {
13214  return m_listCustom.begin();
13215  }
13216 
13218  inline std::list<CParameter *>::iterator
13219  endCustom (void)
13220  {
13221  return m_listCustom.end();
13222  }
13223 
13225  inline void
13227  {
13228  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13229  }
13230 
13232  inline int
13234  {
13235  return (int) (m_listCustom.size());
13236  }
13237 
13238  EResultCode
13240  addCustom (
13241  CParameter * pValue);
13242 
13243 
13244 };
13245 
13246 
13293 class CImpinjDirectionReporting : public CParameter
13294 {
13295  public:
13297  ~CImpinjDirectionReporting (void);
13298 
13301 
13302  static const CFieldDescriptor * const
13303  s_apFieldDescriptorTable[];
13304 
13305  static const CTypeDescriptor
13306  s_typeDescriptor;
13307 
13308  void
13309  decodeFields (
13310  CDecoderStream * pDecoderStream);
13311 
13312  void
13313  assimilateSubParameters (
13314  CErrorDetails * pError);
13315 
13316  void
13317  encode (
13318  CEncoderStream * pEncoderStream) const;
13319 
13320 
13321  llrp_bool_t
13322  isAllowedIn (
13323  const CTypeDescriptor * pEnclosingElementType) const;
13324 
13325 
13326  static CElement *
13327  s_construct (void);
13328 
13329  static void
13330  s_decodeFields (
13331  CDecoderStream * pDecoderStream,
13332  CElement * pElement);
13334 
13335 
13336  protected:
13337  llrp_u1_t m_EnableUpdateReport;
13338 
13341  public:
13342  static const CFieldDescriptor
13343  s_fdEnableUpdateReport;
13345 
13347  inline llrp_u1_t
13349  {
13350  return m_EnableUpdateReport;
13351  }
13352 
13354  inline void
13356  llrp_u1_t value)
13357  {
13358  m_EnableUpdateReport = value;
13359  }
13360 
13361 
13362  protected:
13363  llrp_u1_t m_EnableEntryReport;
13364 
13367  public:
13368  static const CFieldDescriptor
13369  s_fdEnableEntryReport;
13371 
13373  inline llrp_u1_t
13375  {
13376  return m_EnableEntryReport;
13377  }
13378 
13380  inline void
13382  llrp_u1_t value)
13383  {
13384  m_EnableEntryReport = value;
13385  }
13386 
13387 
13388  protected:
13389  llrp_u1_t m_EnableExitReport;
13390 
13393  public:
13394  static const CFieldDescriptor
13395  s_fdEnableExitReport;
13397 
13399  inline llrp_u1_t
13401  {
13402  return m_EnableExitReport;
13403  }
13404 
13406  inline void
13408  llrp_u1_t value)
13409  {
13410  m_EnableExitReport = value;
13411  }
13412 
13413 
13414  protected:
13415  llrp_u1_t m_EnableDiagnosticReport;
13416 
13419  public:
13420  static const CFieldDescriptor
13421  s_fdEnableDiagnosticReport;
13423 
13425  inline llrp_u1_t
13427  {
13428  return m_EnableDiagnosticReport;
13429  }
13430 
13432  inline void
13434  llrp_u1_t value)
13435  {
13436  m_EnableDiagnosticReport = value;
13437  }
13438 
13439 
13440  protected:
13441  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
13442 
13445  public:
13446  static const CFieldDescriptor
13447  s_fdDiagnosticReportLevel;
13449 
13451  inline EImpinjDirectionDiagnosticReportLevel
13453  {
13454  return m_eDiagnosticReportLevel;
13455  }
13456 
13458  inline void
13460  EImpinjDirectionDiagnosticReportLevel value)
13461  {
13462  m_eDiagnosticReportLevel = value;
13463  }
13464 
13465 
13466 
13467  protected:
13468  std::list<CParameter *> m_listCustom;
13469 
13470  public:
13472  inline std::list<CParameter *>::iterator
13474  {
13475  return m_listCustom.begin();
13476  }
13477 
13479  inline std::list<CParameter *>::iterator
13480  endCustom (void)
13481  {
13482  return m_listCustom.end();
13483  }
13484 
13486  inline void
13488  {
13489  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13490  }
13491 
13493  inline int
13495  {
13496  return (int) (m_listCustom.size());
13497  }
13498 
13499  EResultCode
13501  addCustom (
13502  CParameter * pValue);
13503 
13504 
13505 };
13506 
13507 
13555 class CImpinjDirectionReportData : public CParameter
13556 {
13557  public:
13560 
13563 
13564  static const CFieldDescriptor * const
13565  s_apFieldDescriptorTable[];
13566 
13567  static const CTypeDescriptor
13568  s_typeDescriptor;
13569 
13570  void
13571  decodeFields (
13572  CDecoderStream * pDecoderStream);
13573 
13574  void
13575  assimilateSubParameters (
13576  CErrorDetails * pError);
13577 
13578  void
13579  encode (
13580  CEncoderStream * pEncoderStream) const;
13581 
13582 
13583  llrp_bool_t
13584  isAllowedIn (
13585  const CTypeDescriptor * pEnclosingElementType) const;
13586 
13587 
13588  static CElement *
13589  s_construct (void);
13590 
13591  static void
13592  s_decodeFields (
13593  CDecoderStream * pDecoderStream,
13594  CElement * pElement);
13596 
13597 
13598  protected:
13599  EImpinjDirectionReportType m_eType;
13600 
13603  public:
13604  static const CFieldDescriptor
13605  s_fdType;
13607 
13609  inline EImpinjDirectionReportType
13610  getType (void)
13611  {
13612  return m_eType;
13613  }
13614 
13616  inline void
13618  EImpinjDirectionReportType value)
13619  {
13620  m_eType = value;
13621  }
13622 
13623 
13624  protected:
13625  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13626 
13629  public:
13630  static const CFieldDescriptor
13631  s_fdTagPopulationStatus;
13633 
13635  inline EImpinjDirectionTagPopulationStatus
13637  {
13638  return m_eTagPopulationStatus;
13639  }
13640 
13642  inline void
13644  EImpinjDirectionTagPopulationStatus value)
13645  {
13646  m_eTagPopulationStatus = value;
13647  }
13648 
13649 
13650  protected:
13651  llrp_u8_t m_FirstSeenSectorID;
13652 
13655  public:
13656  static const CFieldDescriptor
13657  s_fdFirstSeenSectorID;
13659 
13661  inline llrp_u8_t
13663  {
13664  return m_FirstSeenSectorID;
13665  }
13666 
13668  inline void
13670  llrp_u8_t value)
13671  {
13672  m_FirstSeenSectorID = value;
13673  }
13674 
13675 
13676  protected:
13677  llrp_u64_t m_FirstSeenTimestampUTC;
13678 
13681  public:
13682  static const CFieldDescriptor
13683  s_fdFirstSeenTimestampUTC;
13685 
13687  inline llrp_u64_t
13689  {
13690  return m_FirstSeenTimestampUTC;
13691  }
13692 
13694  inline void
13696  llrp_u64_t value)
13697  {
13698  m_FirstSeenTimestampUTC = value;
13699  }
13700 
13701 
13702  protected:
13703  llrp_u8_t m_LastSeenSectorID;
13704 
13707  public:
13708  static const CFieldDescriptor
13709  s_fdLastSeenSectorID;
13711 
13713  inline llrp_u8_t
13715  {
13716  return m_LastSeenSectorID;
13717  }
13718 
13720  inline void
13722  llrp_u8_t value)
13723  {
13724  m_LastSeenSectorID = value;
13725  }
13726 
13727 
13728  protected:
13729  llrp_u64_t m_LastSeenTimestampUTC;
13730 
13733  public:
13734  static const CFieldDescriptor
13735  s_fdLastSeenTimestampUTC;
13737 
13739  inline llrp_u64_t
13741  {
13742  return m_LastSeenTimestampUTC;
13743  }
13744 
13746  inline void
13748  llrp_u64_t value)
13749  {
13750  m_LastSeenTimestampUTC = value;
13751  }
13752 
13753 
13754 
13755  protected:
13756  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13757 
13758  public:
13762  {
13763  return m_pImpinjDirectionDiagnosticData;
13764  }
13765 
13767  EResultCode
13768  setImpinjDirectionDiagnosticData (
13770 
13771 
13772  protected:
13773  std::list<CParameter *> m_listCustom;
13774 
13775  public:
13777  inline std::list<CParameter *>::iterator
13779  {
13780  return m_listCustom.begin();
13781  }
13782 
13784  inline std::list<CParameter *>::iterator
13785  endCustom (void)
13786  {
13787  return m_listCustom.end();
13788  }
13789 
13791  inline void
13793  {
13794  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13795  }
13796 
13798  inline int
13800  {
13801  return (int) (m_listCustom.size());
13802  }
13803 
13804  EResultCode
13806  addCustom (
13807  CParameter * pValue);
13808 
13809 
13810 };
13811 
13812 
13835 class CImpinjDirectionDiagnosticData : public CParameter
13836 {
13837  public:
13840 
13843 
13844  static const CFieldDescriptor * const
13845  s_apFieldDescriptorTable[];
13846 
13847  static const CTypeDescriptor
13848  s_typeDescriptor;
13849 
13850  void
13851  decodeFields (
13852  CDecoderStream * pDecoderStream);
13853 
13854  void
13855  assimilateSubParameters (
13856  CErrorDetails * pError);
13857 
13858  void
13859  encode (
13860  CEncoderStream * pEncoderStream) const;
13861 
13862 
13863  llrp_bool_t
13864  isAllowedIn (
13865  const CTypeDescriptor * pEnclosingElementType) const;
13866 
13867 
13868  static CElement *
13869  s_construct (void);
13870 
13871  static void
13872  s_decodeFields (
13873  CDecoderStream * pDecoderStream,
13874  CElement * pElement);
13876 
13877 
13878  protected:
13879  llrp_u32v_t m_Metric;
13880 
13883  public:
13884  static const CFieldDescriptor
13885  s_fdMetric;
13887 
13889  inline llrp_u32v_t
13890  getMetric (void)
13891  {
13892  return m_Metric;
13893  }
13894 
13896  inline void
13898  llrp_u32v_t value)
13899  {
13900  m_Metric = value;
13901  }
13902 
13903 
13904 
13905 };
13906 
13907 
13932 class CImpinjxArrayDirectionCapabilities : public CParameter
13933 {
13934  public:
13937 
13940 
13941  static const CFieldDescriptor * const
13942  s_apFieldDescriptorTable[];
13943 
13944  static const CTypeDescriptor
13945  s_typeDescriptor;
13946 
13947  void
13948  decodeFields (
13949  CDecoderStream * pDecoderStream);
13950 
13951  void
13952  assimilateSubParameters (
13953  CErrorDetails * pError);
13954 
13955  void
13956  encode (
13957  CEncoderStream * pEncoderStream) const;
13958 
13959 
13960  llrp_bool_t
13961  isAllowedIn (
13962  const CTypeDescriptor * pEnclosingElementType) const;
13963 
13964 
13965  static CElement *
13966  s_construct (void);
13967 
13968  static void
13969  s_decodeFields (
13970  CDecoderStream * pDecoderStream,
13971  CElement * pElement);
13973 
13974 
13975  protected:
13976  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13977 
13980  public:
13981  static const CFieldDescriptor
13982  s_fdSystemTagPopulationLimitHighSensitivity;
13984 
13986  inline llrp_u16_t
13988  {
13989  return m_SystemTagPopulationLimitHighSensitivity;
13990  }
13991 
13993  inline void
13995  llrp_u16_t value)
13996  {
13997  m_SystemTagPopulationLimitHighSensitivity = value;
13998  }
13999 
14000 
14001  protected:
14002  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
14003 
14006  public:
14007  static const CFieldDescriptor
14008  s_fdSystemTagPopulationLimitHighPerformance;
14010 
14012  inline llrp_u16_t
14014  {
14015  return m_SystemTagPopulationLimitHighPerformance;
14016  }
14017 
14019  inline void
14021  llrp_u16_t value)
14022  {
14023  m_SystemTagPopulationLimitHighPerformance = value;
14024  }
14025 
14026 
14027 
14028  protected:
14029  std::list<CParameter *> m_listCustom;
14030 
14031  public:
14033  inline std::list<CParameter *>::iterator
14035  {
14036  return m_listCustom.begin();
14037  }
14038 
14040  inline std::list<CParameter *>::iterator
14041  endCustom (void)
14042  {
14043  return m_listCustom.end();
14044  }
14045 
14047  inline void
14049  {
14050  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14051  }
14052 
14054  inline int
14056  {
14057  return (int) (m_listCustom.size());
14058  }
14059 
14060  EResultCode
14062  addCustom (
14063  CParameter * pValue);
14064 
14065 
14066 };
14067 
14068 
14094 class CImpinjIntelligentAntennaManagement : public CParameter
14095 {
14096  public:
14099 
14102 
14103  static const CFieldDescriptor * const
14104  s_apFieldDescriptorTable[];
14105 
14106  static const CTypeDescriptor
14107  s_typeDescriptor;
14108 
14109  void
14110  decodeFields (
14111  CDecoderStream * pDecoderStream);
14112 
14113  void
14114  assimilateSubParameters (
14115  CErrorDetails * pError);
14116 
14117  void
14118  encode (
14119  CEncoderStream * pEncoderStream) const;
14120 
14121 
14122  llrp_bool_t
14123  isAllowedIn (
14124  const CTypeDescriptor * pEnclosingElementType) const;
14125 
14126 
14127  static CElement *
14128  s_construct (void);
14129 
14130  static void
14131  s_decodeFields (
14132  CDecoderStream * pDecoderStream,
14133  CElement * pElement);
14135 
14136 
14137  protected:
14138  EImpinjIntelligentAntennaMode m_eManagementEnabled;
14139 
14142  public:
14143  static const CFieldDescriptor
14144  s_fdManagementEnabled;
14146 
14148  inline EImpinjIntelligentAntennaMode
14150  {
14151  return m_eManagementEnabled;
14152  }
14153 
14155  inline void
14157  EImpinjIntelligentAntennaMode value)
14158  {
14159  m_eManagementEnabled = value;
14160  }
14161 
14162 
14163 
14164  protected:
14165  std::list<CParameter *> m_listCustom;
14166 
14167  public:
14169  inline std::list<CParameter *>::iterator
14171  {
14172  return m_listCustom.begin();
14173  }
14174 
14176  inline std::list<CParameter *>::iterator
14177  endCustom (void)
14178  {
14179  return m_listCustom.end();
14180  }
14181 
14183  inline void
14185  {
14186  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14187  }
14188 
14190  inline int
14192  {
14193  return (int) (m_listCustom.size());
14194  }
14195 
14196  EResultCode
14198  addCustom (
14199  CParameter * pValue);
14200 
14201 
14202 };
14203 
14204 
14231 class CImpinjTransmitPower : public CParameter
14232 {
14233  public:
14234  CImpinjTransmitPower (void);
14235  ~CImpinjTransmitPower (void);
14236 
14239 
14240  static const CFieldDescriptor * const
14241  s_apFieldDescriptorTable[];
14242 
14243  static const CTypeDescriptor
14244  s_typeDescriptor;
14245 
14246  void
14247  decodeFields (
14248  CDecoderStream * pDecoderStream);
14249 
14250  void
14251  assimilateSubParameters (
14252  CErrorDetails * pError);
14253 
14254  void
14255  encode (
14256  CEncoderStream * pEncoderStream) const;
14257 
14258 
14259  llrp_bool_t
14260  isAllowedIn (
14261  const CTypeDescriptor * pEnclosingElementType) const;
14262 
14263 
14264  static CElement *
14265  s_construct (void);
14266 
14267  static void
14268  s_decodeFields (
14269  CDecoderStream * pDecoderStream,
14270  CElement * pElement);
14272 
14273 
14274  protected:
14275  llrp_u16_t m_TransmitPower;
14276 
14279  public:
14280  static const CFieldDescriptor
14281  s_fdTransmitPower;
14283 
14285  inline llrp_u16_t
14287  {
14288  return m_TransmitPower;
14289  }
14290 
14292  inline void
14294  llrp_u16_t value)
14295  {
14296  m_TransmitPower = value;
14297  }
14298 
14299 
14300 
14301  protected:
14302  std::list<CParameter *> m_listCustom;
14303 
14304  public:
14306  inline std::list<CParameter *>::iterator
14308  {
14309  return m_listCustom.begin();
14310  }
14311 
14313  inline std::list<CParameter *>::iterator
14314  endCustom (void)
14315  {
14316  return m_listCustom.end();
14317  }
14318 
14320  inline void
14322  {
14323  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14324  }
14325 
14327  inline int
14329  {
14330  return (int) (m_listCustom.size());
14331  }
14332 
14333  EResultCode
14335  addCustom (
14336  CParameter * pValue);
14337 
14338 
14339 };
14340 
14341 
14368 class CImpinjPolarizationControl : public CParameter
14369 {
14370  public:
14373 
14376 
14377  static const CFieldDescriptor * const
14378  s_apFieldDescriptorTable[];
14379 
14380  static const CTypeDescriptor
14381  s_typeDescriptor;
14382 
14383  void
14384  decodeFields (
14385  CDecoderStream * pDecoderStream);
14386 
14387  void
14388  assimilateSubParameters (
14389  CErrorDetails * pError);
14390 
14391  void
14392  encode (
14393  CEncoderStream * pEncoderStream) const;
14394 
14395 
14396  llrp_bool_t
14397  isAllowedIn (
14398  const CTypeDescriptor * pEnclosingElementType) const;
14399 
14400 
14401  static CElement *
14402  s_construct (void);
14403 
14404  static void
14405  s_decodeFields (
14406  CDecoderStream * pDecoderStream,
14407  CElement * pElement);
14409 
14410 
14411  protected:
14412  llrp_u1_t m_PolarizationControlEnabled;
14413 
14416  public:
14417  static const CFieldDescriptor
14418  s_fdPolarizationControlEnabled;
14420 
14422  inline llrp_u1_t
14424  {
14425  return m_PolarizationControlEnabled;
14426  }
14427 
14429  inline void
14431  llrp_u1_t value)
14432  {
14433  m_PolarizationControlEnabled = value;
14434  }
14435 
14436 
14437 
14438  protected:
14439  std::list<CParameter *> m_listCustom;
14440 
14441  public:
14443  inline std::list<CParameter *>::iterator
14445  {
14446  return m_listCustom.begin();
14447  }
14448 
14450  inline std::list<CParameter *>::iterator
14451  endCustom (void)
14452  {
14453  return m_listCustom.end();
14454  }
14455 
14457  inline void
14459  {
14460  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14461  }
14462 
14464  inline int
14466  {
14467  return (int) (m_listCustom.size());
14468  }
14469 
14470  EResultCode
14472  addCustom (
14473  CParameter * pValue);
14474 
14475 
14476 };
14477 
14478 
14503 class CImpinjAntennaCapabilities : public CParameter
14504 {
14505  public:
14508 
14511 
14512  static const CFieldDescriptor * const
14513  s_apFieldDescriptorTable[];
14514 
14515  static const CTypeDescriptor
14516  s_typeDescriptor;
14517 
14518  void
14519  decodeFields (
14520  CDecoderStream * pDecoderStream);
14521 
14522  void
14523  assimilateSubParameters (
14524  CErrorDetails * pError);
14525 
14526  void
14527  encode (
14528  CEncoderStream * pEncoderStream) const;
14529 
14530 
14531  llrp_bool_t
14532  isAllowedIn (
14533  const CTypeDescriptor * pEnclosingElementType) const;
14534 
14535 
14536  static CElement *
14537  s_construct (void);
14538 
14539  static void
14540  s_decodeFields (
14541  CDecoderStream * pDecoderStream,
14542  CElement * pElement);
14544 
14545 
14546 
14547  protected:
14548  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
14549 
14550  public:
14552  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14554  {
14555  return m_listImpinjAntennaPolarizationCapability.begin();
14556  }
14557 
14559  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14561  {
14562  return m_listImpinjAntennaPolarizationCapability.end();
14563  }
14564 
14566  inline void
14568  {
14569  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
14570  }
14571 
14573  inline int
14575  {
14576  return (int) (m_listImpinjAntennaPolarizationCapability.size());
14577  }
14578 
14579  EResultCode
14581  addImpinjAntennaPolarizationCapability (
14583 
14584 
14585  protected:
14586  std::list<CParameter *> m_listCustom;
14587 
14588  public:
14590  inline std::list<CParameter *>::iterator
14592  {
14593  return m_listCustom.begin();
14594  }
14595 
14597  inline std::list<CParameter *>::iterator
14598  endCustom (void)
14599  {
14600  return m_listCustom.end();
14601  }
14602 
14604  inline void
14606  {
14607  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14608  }
14609 
14611  inline int
14613  {
14614  return (int) (m_listCustom.size());
14615  }
14616 
14617  EResultCode
14619  addCustom (
14620  CParameter * pValue);
14621 
14622 
14623 };
14624 
14625 
14650 class CImpinjAntennaPolarizationCapability : public CParameter
14651 {
14652  public:
14655 
14658 
14659  static const CFieldDescriptor * const
14660  s_apFieldDescriptorTable[];
14661 
14662  static const CTypeDescriptor
14663  s_typeDescriptor;
14664 
14665  void
14666  decodeFields (
14667  CDecoderStream * pDecoderStream);
14668 
14669  void
14670  assimilateSubParameters (
14671  CErrorDetails * pError);
14672 
14673  void
14674  encode (
14675  CEncoderStream * pEncoderStream) const;
14676 
14677 
14678  llrp_bool_t
14679  isAllowedIn (
14680  const CTypeDescriptor * pEnclosingElementType) const;
14681 
14682 
14683  static CElement *
14684  s_construct (void);
14685 
14686  static void
14687  s_decodeFields (
14688  CDecoderStream * pDecoderStream,
14689  CElement * pElement);
14691 
14692 
14693  protected:
14694  EImpinjAntennaPolarizationType m_eType;
14695 
14698  public:
14699  static const CFieldDescriptor
14700  s_fdType;
14702 
14704  inline EImpinjAntennaPolarizationType
14705  getType (void)
14706  {
14707  return m_eType;
14708  }
14709 
14711  inline void
14713  EImpinjAntennaPolarizationType value)
14714  {
14715  m_eType = value;
14716  }
14717 
14718 
14719  protected:
14720  llrp_u16_t m_AntennaIDOffset;
14721 
14724  public:
14725  static const CFieldDescriptor
14726  s_fdAntennaIDOffset;
14728 
14730  inline llrp_u16_t
14732  {
14733  return m_AntennaIDOffset;
14734  }
14735 
14737  inline void
14739  llrp_u16_t value)
14740  {
14741  m_AntennaIDOffset = value;
14742  }
14743 
14744 
14745 
14746  protected:
14747  std::list<CParameter *> m_listCustom;
14748 
14749  public:
14751  inline std::list<CParameter *>::iterator
14753  {
14754  return m_listCustom.begin();
14755  }
14756 
14758  inline std::list<CParameter *>::iterator
14759  endCustom (void)
14760  {
14761  return m_listCustom.end();
14762  }
14763 
14765  inline void
14767  {
14768  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14769  }
14770 
14772  inline int
14774  {
14775  return (int) (m_listCustom.size());
14776  }
14777 
14778  EResultCode
14780  addCustom (
14781  CParameter * pValue);
14782 
14783 
14784 };
14785 
14786 
14810 class CImpinjDisabledAntennas : public CParameter
14811 {
14812  public:
14813  CImpinjDisabledAntennas (void);
14814  ~CImpinjDisabledAntennas (void);
14815 
14818 
14819  static const CFieldDescriptor * const
14820  s_apFieldDescriptorTable[];
14821 
14822  static const CTypeDescriptor
14823  s_typeDescriptor;
14824 
14825  void
14826  decodeFields (
14827  CDecoderStream * pDecoderStream);
14828 
14829  void
14830  assimilateSubParameters (
14831  CErrorDetails * pError);
14832 
14833  void
14834  encode (
14835  CEncoderStream * pEncoderStream) const;
14836 
14837 
14838  llrp_bool_t
14839  isAllowedIn (
14840  const CTypeDescriptor * pEnclosingElementType) const;
14841 
14842 
14843  static CElement *
14844  s_construct (void);
14845 
14846  static void
14847  s_decodeFields (
14848  CDecoderStream * pDecoderStream,
14849  CElement * pElement);
14851 
14852 
14853  protected:
14854  llrp_u16v_t m_AntennaIDs;
14855 
14858  public:
14859  static const CFieldDescriptor
14860  s_fdAntennaIDs;
14862 
14864  inline llrp_u16v_t
14866  {
14867  return m_AntennaIDs;
14868  }
14869 
14871  inline void
14873  llrp_u16v_t value)
14874  {
14875  m_AntennaIDs = value;
14876  }
14877 
14878 
14879 
14880  protected:
14881  std::list<CParameter *> m_listCustom;
14882 
14883  public:
14885  inline std::list<CParameter *>::iterator
14887  {
14888  return m_listCustom.begin();
14889  }
14890 
14892  inline std::list<CParameter *>::iterator
14893  endCustom (void)
14894  {
14895  return m_listCustom.end();
14896  }
14897 
14899  inline void
14901  {
14902  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14903  }
14904 
14906  inline int
14908  {
14909  return (int) (m_listCustom.size());
14910  }
14911 
14912  EResultCode
14914  addCustom (
14915  CParameter * pValue);
14916 
14917 
14918 };
14919 
14920 
14945 class CImpinjTIDParity : public CParameter
14946 {
14947  public:
14948  CImpinjTIDParity (void);
14949  ~CImpinjTIDParity (void);
14950 
14953 
14954  static const CFieldDescriptor * const
14955  s_apFieldDescriptorTable[];
14956 
14957  static const CTypeDescriptor
14958  s_typeDescriptor;
14959 
14960  void
14961  decodeFields (
14962  CDecoderStream * pDecoderStream);
14963 
14964  void
14965  assimilateSubParameters (
14966  CErrorDetails * pError);
14967 
14968  void
14969  encode (
14970  CEncoderStream * pEncoderStream) const;
14971 
14972 
14973  llrp_bool_t
14974  isAllowedIn (
14975  const CTypeDescriptor * pEnclosingElementType) const;
14976 
14977 
14978  static CElement *
14979  s_construct (void);
14980 
14981  static void
14982  s_decodeFields (
14983  CDecoderStream * pDecoderStream,
14984  CElement * pElement);
14986 
14987 
14988  protected:
14989  llrp_u1_t m_ParityError;
14990 
14993  public:
14994  static const CFieldDescriptor
14995  s_fdParityError;
14997 
14999  inline llrp_u1_t
15001  {
15002  return m_ParityError;
15003  }
15004 
15006  inline void
15008  llrp_u1_t value)
15009  {
15010  m_ParityError = value;
15011  }
15012 
15013 
15014 
15015  protected:
15016  std::list<CParameter *> m_listCustom;
15017 
15018  public:
15020  inline std::list<CParameter *>::iterator
15022  {
15023  return m_listCustom.begin();
15024  }
15025 
15027  inline std::list<CParameter *>::iterator
15028  endCustom (void)
15029  {
15030  return m_listCustom.end();
15031  }
15032 
15034  inline void
15036  {
15037  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15038  }
15039 
15041  inline int
15043  {
15044  return (int) (m_listCustom.size());
15045  }
15046 
15047  EResultCode
15049  addCustom (
15050  CParameter * pValue);
15051 
15052 
15053 };
15054 
15055 
15086 class CImpinjMarginRead : public CParameter
15087 {
15088  public:
15089  CImpinjMarginRead (void);
15090  ~CImpinjMarginRead (void);
15091 
15094 
15095  static const CFieldDescriptor * const
15096  s_apFieldDescriptorTable[];
15097 
15098  static const CTypeDescriptor
15099  s_typeDescriptor;
15100 
15101  void
15102  decodeFields (
15103  CDecoderStream * pDecoderStream);
15104 
15105  void
15106  assimilateSubParameters (
15107  CErrorDetails * pError);
15108 
15109  void
15110  encode (
15111  CEncoderStream * pEncoderStream) const;
15112 
15113 
15114  llrp_bool_t
15115  isAllowedIn (
15116  const CTypeDescriptor * pEnclosingElementType) const;
15117 
15118 
15119  static CElement *
15120  s_construct (void);
15121 
15122  static void
15123  s_decodeFields (
15124  CDecoderStream * pDecoderStream,
15125  CElement * pElement);
15127 
15128 
15129  protected:
15130  llrp_u16_t m_OpSpecID;
15131 
15134  public:
15135  static const CFieldDescriptor
15136  s_fdOpSpecID;
15138 
15140  inline llrp_u16_t
15142  {
15143  return m_OpSpecID;
15144  }
15145 
15147  inline void
15149  llrp_u16_t value)
15150  {
15151  m_OpSpecID = value;
15152  }
15153 
15154 
15155  protected:
15156  llrp_u32_t m_AccessPassword;
15157 
15160  public:
15161  static const CFieldDescriptor
15162  s_fdAccessPassword;
15164 
15166  inline llrp_u32_t
15168  {
15169  return m_AccessPassword;
15170  }
15171 
15173  inline void
15175  llrp_u32_t value)
15176  {
15177  m_AccessPassword = value;
15178  }
15179 
15180 
15181  protected:
15182  llrp_u2_t m_MB;
15183 
15186  public:
15187  static const CFieldDescriptor
15188  s_fdMB;
15190 
15192  inline llrp_u2_t
15193  getMB (void)
15194  {
15195  return m_MB;
15196  }
15197 
15199  inline void
15201  llrp_u2_t value)
15202  {
15203  m_MB = value;
15204  }
15205 
15206 
15207  protected:
15208  llrp_u16_t m_BitPointer;
15209 
15212  public:
15213  static const CFieldDescriptor
15214  s_fdBitPointer;
15216 
15218  inline llrp_u16_t
15220  {
15221  return m_BitPointer;
15222  }
15223 
15225  inline void
15227  llrp_u16_t value)
15228  {
15229  m_BitPointer = value;
15230  }
15231 
15232 
15233  protected:
15234  llrp_u8_t m_BitLength;
15235 
15238  public:
15239  static const CFieldDescriptor
15240  s_fdBitLength;
15242 
15244  inline llrp_u8_t
15246  {
15247  return m_BitLength;
15248  }
15249 
15251  inline void
15253  llrp_u8_t value)
15254  {
15255  m_BitLength = value;
15256  }
15257 
15258 
15259  protected:
15260  llrp_u16v_t m_Mask;
15261 
15264  public:
15265  static const CFieldDescriptor
15266  s_fdMask;
15268 
15270  inline llrp_u16v_t
15271  getMask (void)
15272  {
15273  return m_Mask;
15274  }
15275 
15277  inline void
15279  llrp_u16v_t value)
15280  {
15281  m_Mask = value;
15282  }
15283 
15284 
15285 
15286  protected:
15287  std::list<CParameter *> m_listCustom;
15288 
15289  public:
15291  inline std::list<CParameter *>::iterator
15293  {
15294  return m_listCustom.begin();
15295  }
15296 
15298  inline std::list<CParameter *>::iterator
15299  endCustom (void)
15300  {
15301  return m_listCustom.end();
15302  }
15303 
15305  inline void
15307  {
15308  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15309  }
15310 
15312  inline int
15314  {
15315  return (int) (m_listCustom.size());
15316  }
15317 
15318  EResultCode
15320  addCustom (
15321  CParameter * pValue);
15322 
15323 
15324 };
15325 
15326 
15352 class CImpinjMarginReadOpSpecResult : public CParameter
15353 {
15354  public:
15357 
15360 
15361  static const CFieldDescriptor * const
15362  s_apFieldDescriptorTable[];
15363 
15364  static const CTypeDescriptor
15365  s_typeDescriptor;
15366 
15367  void
15368  decodeFields (
15369  CDecoderStream * pDecoderStream);
15370 
15371  void
15372  assimilateSubParameters (
15373  CErrorDetails * pError);
15374 
15375  void
15376  encode (
15377  CEncoderStream * pEncoderStream) const;
15378 
15379 
15380  llrp_bool_t
15381  isAllowedIn (
15382  const CTypeDescriptor * pEnclosingElementType) const;
15383 
15384 
15385  static CElement *
15386  s_construct (void);
15387 
15388  static void
15389  s_decodeFields (
15390  CDecoderStream * pDecoderStream,
15391  CElement * pElement);
15393 
15394 
15395  protected:
15396  EImpinjMarginReadResultType m_eResult;
15397 
15400  public:
15401  static const CFieldDescriptor
15402  s_fdResult;
15404 
15406  inline EImpinjMarginReadResultType
15407  getResult (void)
15408  {
15409  return m_eResult;
15410  }
15411 
15413  inline void
15415  EImpinjMarginReadResultType value)
15416  {
15417  m_eResult = value;
15418  }
15419 
15420 
15421  protected:
15422  llrp_u16_t m_OpSpecID;
15423 
15426  public:
15427  static const CFieldDescriptor
15428  s_fdOpSpecID;
15430 
15432  inline llrp_u16_t
15434  {
15435  return m_OpSpecID;
15436  }
15437 
15439  inline void
15441  llrp_u16_t value)
15442  {
15443  m_OpSpecID = value;
15444  }
15445 
15446 
15447 
15448  protected:
15449  std::list<CParameter *> m_listCustom;
15450 
15451  public:
15453  inline std::list<CParameter *>::iterator
15455  {
15456  return m_listCustom.begin();
15457  }
15458 
15460  inline std::list<CParameter *>::iterator
15461  endCustom (void)
15462  {
15463  return m_listCustom.end();
15464  }
15465 
15467  inline void
15469  {
15470  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15471  }
15472 
15474  inline int
15476  {
15477  return (int) (m_listCustom.size());
15478  }
15479 
15480  EResultCode
15482  addCustom (
15483  CParameter * pValue);
15484 
15485 
15486 };
15487 
15488 
15513 class CImpinjBLEVersion : public CParameter
15514 {
15515  public:
15516  CImpinjBLEVersion (void);
15517  ~CImpinjBLEVersion (void);
15518 
15521 
15522  static const CFieldDescriptor * const
15523  s_apFieldDescriptorTable[];
15524 
15525  static const CTypeDescriptor
15526  s_typeDescriptor;
15527 
15528  void
15529  decodeFields (
15530  CDecoderStream * pDecoderStream);
15531 
15532  void
15533  assimilateSubParameters (
15534  CErrorDetails * pError);
15535 
15536  void
15537  encode (
15538  CEncoderStream * pEncoderStream) const;
15539 
15540 
15541  llrp_bool_t
15542  isAllowedIn (
15543  const CTypeDescriptor * pEnclosingElementType) const;
15544 
15545 
15546  static CElement *
15547  s_construct (void);
15548 
15549  static void
15550  s_decodeFields (
15551  CDecoderStream * pDecoderStream,
15552  CElement * pElement);
15554 
15555 
15556  protected:
15557  llrp_utf8v_t m_FirmwareVersion;
15558 
15561  public:
15562  static const CFieldDescriptor
15563  s_fdFirmwareVersion;
15565 
15567  inline llrp_utf8v_t
15569  {
15570  return m_FirmwareVersion;
15571  }
15572 
15574  inline void
15576  llrp_utf8v_t value)
15577  {
15578  m_FirmwareVersion = value;
15579  }
15580 
15581 
15582 
15583  protected:
15584  std::list<CParameter *> m_listCustom;
15585 
15586  public:
15588  inline std::list<CParameter *>::iterator
15590  {
15591  return m_listCustom.begin();
15592  }
15593 
15595  inline std::list<CParameter *>::iterator
15596  endCustom (void)
15597  {
15598  return m_listCustom.end();
15599  }
15600 
15602  inline void
15604  {
15605  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15606  }
15607 
15609  inline int
15611  {
15612  return (int) (m_listCustom.size());
15613  }
15614 
15615  EResultCode
15617  addCustom (
15618  CParameter * pValue);
15619 
15620 
15621 };
15622 
15623 
15647 class CImpinjLocationAlgorithmControl : public CParameter
15648 {
15649  public:
15652 
15655 
15656  static const CFieldDescriptor * const
15657  s_apFieldDescriptorTable[];
15658 
15659  static const CTypeDescriptor
15660  s_typeDescriptor;
15661 
15662  void
15663  decodeFields (
15664  CDecoderStream * pDecoderStream);
15665 
15666  void
15667  assimilateSubParameters (
15668  CErrorDetails * pError);
15669 
15670  void
15671  encode (
15672  CEncoderStream * pEncoderStream) const;
15673 
15674 
15675  llrp_bool_t
15676  isAllowedIn (
15677  const CTypeDescriptor * pEnclosingElementType) const;
15678 
15679 
15680  static CElement *
15681  s_construct (void);
15682 
15683  static void
15684  s_decodeFields (
15685  CDecoderStream * pDecoderStream,
15686  CElement * pElement);
15688 
15689 
15690  protected:
15691  llrp_u32v_t m_ControlData;
15692 
15695  public:
15696  static const CFieldDescriptor
15697  s_fdControlData;
15699 
15701  inline llrp_u32v_t
15703  {
15704  return m_ControlData;
15705  }
15706 
15708  inline void
15710  llrp_u32v_t value)
15711  {
15712  m_ControlData = value;
15713  }
15714 
15715 
15716 
15717  protected:
15718  std::list<CParameter *> m_listCustom;
15719 
15720  public:
15722  inline std::list<CParameter *>::iterator
15724  {
15725  return m_listCustom.begin();
15726  }
15727 
15729  inline std::list<CParameter *>::iterator
15730  endCustom (void)
15731  {
15732  return m_listCustom.end();
15733  }
15734 
15736  inline void
15738  {
15739  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15740  }
15741 
15743  inline int
15745  {
15746  return (int) (m_listCustom.size());
15747  }
15748 
15749  EResultCode
15751  addCustom (
15752  CParameter * pValue);
15753 
15754 
15755 };
15756 
15757 
15794 class CImpinjRFPowerSweep : public CParameter
15795 {
15796  public:
15797  CImpinjRFPowerSweep (void);
15798  ~CImpinjRFPowerSweep (void);
15799 
15802 
15803  static const CFieldDescriptor * const
15804  s_apFieldDescriptorTable[];
15805 
15806  static const CTypeDescriptor
15807  s_typeDescriptor;
15808 
15809  void
15810  decodeFields (
15811  CDecoderStream * pDecoderStream);
15812 
15813  void
15814  assimilateSubParameters (
15815  CErrorDetails * pError);
15816 
15817  void
15818  encode (
15819  CEncoderStream * pEncoderStream) const;
15820 
15821 
15822  llrp_bool_t
15823  isAllowedIn (
15824  const CTypeDescriptor * pEnclosingElementType) const;
15825 
15826 
15827  static CElement *
15828  s_construct (void);
15829 
15830  static void
15831  s_decodeFields (
15832  CDecoderStream * pDecoderStream,
15833  CElement * pElement);
15835 
15836 
15837  protected:
15838  llrp_u1_t m_EnableRFPowerSweep;
15839 
15842  public:
15843  static const CFieldDescriptor
15844  s_fdEnableRFPowerSweep;
15846 
15848  inline llrp_u1_t
15850  {
15851  return m_EnableRFPowerSweep;
15852  }
15853 
15855  inline void
15857  llrp_u1_t value)
15858  {
15859  m_EnableRFPowerSweep = value;
15860  }
15861 
15862 
15863  protected:
15864  llrp_u16_t m_MinimumPowerLevel;
15865 
15868  public:
15869  static const CFieldDescriptor
15870  s_fdMinimumPowerLevel;
15872 
15874  inline llrp_u16_t
15876  {
15877  return m_MinimumPowerLevel;
15878  }
15879 
15881  inline void
15883  llrp_u16_t value)
15884  {
15885  m_MinimumPowerLevel = value;
15886  }
15887 
15888 
15889  protected:
15890  llrp_u16_t m_PowerLevelStepSize;
15891 
15894  public:
15895  static const CFieldDescriptor
15896  s_fdPowerLevelStepSize;
15898 
15900  inline llrp_u16_t
15902  {
15903  return m_PowerLevelStepSize;
15904  }
15905 
15907  inline void
15909  llrp_u16_t value)
15910  {
15911  m_PowerLevelStepSize = value;
15912  }
15913 
15914 
15915 
15916  protected:
15917  std::list<CParameter *> m_listCustom;
15918 
15919  public:
15921  inline std::list<CParameter *>::iterator
15923  {
15924  return m_listCustom.begin();
15925  }
15926 
15928  inline std::list<CParameter *>::iterator
15929  endCustom (void)
15930  {
15931  return m_listCustom.end();
15932  }
15933 
15935  inline void
15937  {
15938  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15939  }
15940 
15942  inline int
15944  {
15945  return (int) (m_listCustom.size());
15946  }
15947 
15948  EResultCode
15950  addCustom (
15951  CParameter * pValue);
15952 
15953 
15954 };
15955 
15956 
15997 class CImpinjTruncatedReplyConfiguration : public CParameter
15998 {
15999  public:
16002 
16005 
16006  static const CFieldDescriptor * const
16007  s_apFieldDescriptorTable[];
16008 
16009  static const CTypeDescriptor
16010  s_typeDescriptor;
16011 
16012  void
16013  decodeFields (
16014  CDecoderStream * pDecoderStream);
16015 
16016  void
16017  assimilateSubParameters (
16018  CErrorDetails * pError);
16019 
16020  void
16021  encode (
16022  CEncoderStream * pEncoderStream) const;
16023 
16024 
16025  llrp_bool_t
16026  isAllowedIn (
16027  const CTypeDescriptor * pEnclosingElementType) const;
16028 
16029 
16030  static CElement *
16031  s_construct (void);
16032 
16033  static void
16034  s_decodeFields (
16035  CDecoderStream * pDecoderStream,
16036  CElement * pElement);
16038 
16039 
16040  protected:
16041  llrp_u1_t m_Gen2v2TagsOnly;
16042 
16045  public:
16046  static const CFieldDescriptor
16047  s_fdGen2v2TagsOnly;
16049 
16051  inline llrp_u1_t
16053  {
16054  return m_Gen2v2TagsOnly;
16055  }
16056 
16058  inline void
16060  llrp_u1_t value)
16061  {
16062  m_Gen2v2TagsOnly = value;
16063  }
16064 
16065 
16066  protected:
16067  llrp_u8_t m_EPCLength;
16068 
16071  public:
16072  static const CFieldDescriptor
16073  s_fdEPCLength;
16075 
16077  inline llrp_u8_t
16079  {
16080  return m_EPCLength;
16081  }
16082 
16084  inline void
16086  llrp_u8_t value)
16087  {
16088  m_EPCLength = value;
16089  }
16090 
16091 
16092  protected:
16093  llrp_u16_t m_Pointer;
16094 
16097  public:
16098  static const CFieldDescriptor
16099  s_fdPointer;
16101 
16103  inline llrp_u16_t
16104  getPointer (void)
16105  {
16106  return m_Pointer;
16107  }
16108 
16110  inline void
16112  llrp_u16_t value)
16113  {
16114  m_Pointer = value;
16115  }
16116 
16117 
16118  protected:
16119  llrp_u1v_t m_TagMask;
16120 
16123  public:
16124  static const CFieldDescriptor
16125  s_fdTagMask;
16127 
16129  inline llrp_u1v_t
16130  getTagMask (void)
16131  {
16132  return m_TagMask;
16133  }
16134 
16136  inline void
16138  llrp_u1v_t value)
16139  {
16140  m_TagMask = value;
16141  }
16142 
16143 
16144 
16145  protected:
16146  std::list<CParameter *> m_listCustom;
16147 
16148  public:
16150  inline std::list<CParameter *>::iterator
16152  {
16153  return m_listCustom.begin();
16154  }
16155 
16157  inline std::list<CParameter *>::iterator
16158  endCustom (void)
16159  {
16160  return m_listCustom.end();
16161  }
16162 
16164  inline void
16166  {
16167  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16168  }
16169 
16171  inline int
16173  {
16174  return (int) (m_listCustom.size());
16175  }
16176 
16177  EResultCode
16179  addCustom (
16180  CParameter * pValue);
16181 
16182 
16183 };
16184 
16185 
16231 class CImpinjAuthenticate : public CParameter
16232 {
16233  public:
16234  CImpinjAuthenticate (void);
16235  ~CImpinjAuthenticate (void);
16236 
16239 
16240  static const CFieldDescriptor * const
16241  s_apFieldDescriptorTable[];
16242 
16243  static const CTypeDescriptor
16244  s_typeDescriptor;
16245 
16246  void
16247  decodeFields (
16248  CDecoderStream * pDecoderStream);
16249 
16250  void
16251  assimilateSubParameters (
16252  CErrorDetails * pError);
16253 
16254  void
16255  encode (
16256  CEncoderStream * pEncoderStream) const;
16257 
16258 
16259  llrp_bool_t
16260  isAllowedIn (
16261  const CTypeDescriptor * pEnclosingElementType) const;
16262 
16263 
16264  static CElement *
16265  s_construct (void);
16266 
16267  static void
16268  s_decodeFields (
16269  CDecoderStream * pDecoderStream,
16270  CElement * pElement);
16272 
16273 
16274  protected:
16275  llrp_u16_t m_OpSpecID;
16276 
16279  public:
16280  static const CFieldDescriptor
16281  s_fdOpSpecID;
16283 
16285  inline llrp_u16_t
16287  {
16288  return m_OpSpecID;
16289  }
16290 
16292  inline void
16294  llrp_u16_t value)
16295  {
16296  m_OpSpecID = value;
16297  }
16298 
16299 
16300  protected:
16301  llrp_u32_t m_AccessPassword;
16302 
16305  public:
16306  static const CFieldDescriptor
16307  s_fdAccessPassword;
16309 
16311  inline llrp_u32_t
16313  {
16314  return m_AccessPassword;
16315  }
16316 
16318  inline void
16320  llrp_u32_t value)
16321  {
16322  m_AccessPassword = value;
16323  }
16324 
16325 
16326  protected:
16327  llrp_u1_t m_SendRep;
16328 
16331  public:
16332  static const CFieldDescriptor
16333  s_fdSendRep;
16335 
16337  inline llrp_u1_t
16338  getSendRep (void)
16339  {
16340  return m_SendRep;
16341  }
16342 
16344  inline void
16346  llrp_u1_t value)
16347  {
16348  m_SendRep = value;
16349  }
16350 
16351 
16352  protected:
16353  llrp_u1_t m_IncRepLen;
16354 
16357  public:
16358  static const CFieldDescriptor
16359  s_fdIncRepLen;
16361 
16363  inline llrp_u1_t
16365  {
16366  return m_IncRepLen;
16367  }
16368 
16370  inline void
16372  llrp_u1_t value)
16373  {
16374  m_IncRepLen = value;
16375  }
16376 
16377 
16378  protected:
16379  llrp_u8_t m_CSI;
16380 
16383  public:
16384  static const CFieldDescriptor
16385  s_fdCSI;
16387 
16389  inline llrp_u8_t
16390  getCSI (void)
16391  {
16392  return m_CSI;
16393  }
16394 
16396  inline void
16398  llrp_u8_t value)
16399  {
16400  m_CSI = value;
16401  }
16402 
16403 
16404  protected:
16405  llrp_u1v_t m_Message;
16406 
16409  public:
16410  static const CFieldDescriptor
16411  s_fdMessage;
16413 
16415  inline llrp_u1v_t
16416  getMessage (void)
16417  {
16418  return m_Message;
16419  }
16420 
16422  inline void
16424  llrp_u1v_t value)
16425  {
16426  m_Message = value;
16427  }
16428 
16429 
16430 
16431  protected:
16432  std::list<CParameter *> m_listCustom;
16433 
16434  public:
16436  inline std::list<CParameter *>::iterator
16438  {
16439  return m_listCustom.begin();
16440  }
16441 
16443  inline std::list<CParameter *>::iterator
16444  endCustom (void)
16445  {
16446  return m_listCustom.end();
16447  }
16448 
16450  inline void
16452  {
16453  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16454  }
16455 
16457  inline int
16459  {
16460  return (int) (m_listCustom.size());
16461  }
16462 
16463  EResultCode
16465  addCustom (
16466  CParameter * pValue);
16467 
16468 
16469 };
16470 
16471 
16501 class CImpinjAuthenticateOpSpecResult : public CParameter
16502 {
16503  public:
16506 
16509 
16510  static const CFieldDescriptor * const
16511  s_apFieldDescriptorTable[];
16512 
16513  static const CTypeDescriptor
16514  s_typeDescriptor;
16515 
16516  void
16517  decodeFields (
16518  CDecoderStream * pDecoderStream);
16519 
16520  void
16521  assimilateSubParameters (
16522  CErrorDetails * pError);
16523 
16524  void
16525  encode (
16526  CEncoderStream * pEncoderStream) const;
16527 
16528 
16529  llrp_bool_t
16530  isAllowedIn (
16531  const CTypeDescriptor * pEnclosingElementType) const;
16532 
16533 
16534  static CElement *
16535  s_construct (void);
16536 
16537  static void
16538  s_decodeFields (
16539  CDecoderStream * pDecoderStream,
16540  CElement * pElement);
16542 
16543 
16544  protected:
16545  EImpinjAuthenticateResultType m_eResult;
16546 
16549  public:
16550  static const CFieldDescriptor
16551  s_fdResult;
16553 
16555  inline EImpinjAuthenticateResultType
16556  getResult (void)
16557  {
16558  return m_eResult;
16559  }
16560 
16562  inline void
16564  EImpinjAuthenticateResultType value)
16565  {
16566  m_eResult = value;
16567  }
16568 
16569 
16570  protected:
16571  llrp_u16_t m_OpSpecID;
16572 
16575  public:
16576  static const CFieldDescriptor
16577  s_fdOpSpecID;
16579 
16581  inline llrp_u16_t
16583  {
16584  return m_OpSpecID;
16585  }
16586 
16588  inline void
16590  llrp_u16_t value)
16591  {
16592  m_OpSpecID = value;
16593  }
16594 
16595 
16596  protected:
16597  llrp_u1v_t m_Response;
16598 
16601  public:
16602  static const CFieldDescriptor
16603  s_fdResponse;
16605 
16607  inline llrp_u1v_t
16609  {
16610  return m_Response;
16611  }
16612 
16614  inline void
16616  llrp_u1v_t value)
16617  {
16618  m_Response = value;
16619  }
16620 
16621 
16622 
16623  protected:
16624  std::list<CParameter *> m_listCustom;
16625 
16626  public:
16628  inline std::list<CParameter *>::iterator
16630  {
16631  return m_listCustom.begin();
16632  }
16633 
16635  inline std::list<CParameter *>::iterator
16636  endCustom (void)
16637  {
16638  return m_listCustom.end();
16639  }
16640 
16642  inline void
16644  {
16645  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16646  }
16647 
16649  inline int
16651  {
16652  return (int) (m_listCustom.size());
16653  }
16654 
16655  EResultCode
16657  addCustom (
16658  CParameter * pValue);
16659 
16660 
16661 };
16662 
16663 
16678 extern void
16680  CTypeRegistry * pTypeRegistry);
CImpinjOpSpecRetryCount * getImpinjOpSpecRetryCount(void)
Get accessor functions for the LLRP ImpinjOpSpecRetryCount sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLowDutyCycleMode getLowDutyCycleMode(void)
Get accessor functions for the LLRP LowDutyCycleMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAccessSpecOrderingMode getOrderingMode(void)
Get accessor functions for the LLRP OrderingMode field.
void setSystemTagPopulationLimitHighSensitivity(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjTagReportContentSelector for LLRP parameter ImpinjTagReportContentSelector.
llrp_u16_t getGPOPortNum(void)
Get accessor functions for the LLRP GPOPortNum field.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
Class Definition CImpinjPlacementConfiguration for LLRP parameter ImpinjPlacementConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjIntelligentAntennaManagement for LLRP parameter ImpinjIntelligentAntennaManag...
CImpinjHubVersions * getImpinjHubVersions(void)
Get accessor functions for the LLRP ImpinjHubVersions sub-parameter.
llrp_utf8v_t getRMCSentence(void)
Get accessor functions for the LLRP RMCSentence field.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16_t getRetryCount(void)
Get accessor functions for the LLRP RetryCount field.
llrp_u1_t getParityError(void)
Get accessor functions for the LLRP ParityError field.
CImpinjArrayVersion * getImpinjArrayVersion(void)
Get accessor functions for the LLRP ImpinjArrayVersion sub-parameter.
Class Definition CImpinjGetQTConfigOpSpecResult for LLRP parameter ImpinjGetQTConfigOpSpecResult.
void setTxPower(llrp_u16_t value)
Set accessor functions for the LLRP TxPower field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setFieldOfView(EImpinjDirectionFieldOfView value)
Set accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getBeaconState(void)
Get accessor functions for the LLRP BeaconState field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s32_t getFacilityYLocationCm(void)
Get accessor functions for the LLRP FacilityYLocationCm field.
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjInventoryConfiguration for LLRP parameter ImpinjInventoryConfiguration.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubConnectedType getConnected(void)
Get accessor functions for the LLRP Connected field.
llrp_u16_t getBitPointer(void)
Get accessor functions for the LLRP BitPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setType(EImpinjAntennaPolarizationType value)
Set accessor functions for the LLRP Type field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLoopSpec for LLRP parameter ImpinjLoopSpec.
Class Definition CImpinjSubRegulatoryRegion for LLRP parameter ImpinjSubRegulatoryRegion.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjTransmitPower for LLRP parameter ImpinjTransmitPower.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getControlData(void)
Get accessor functions for the LLRP ControlData field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getLastSeenSectorID(void)
Get accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConnected(EImpinjHubConnectedType value)
Set accessor functions for the LLRP Connected field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModelName(llrp_utf8v_t value)
Set accessor functions for the LLRP ModelName field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setBeaconState(llrp_u1_t value)
Set accessor functions for the LLRP BeaconState field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjFixedFrequencyList for LLRP parameter ImpinjFixedFrequencyList.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CIMPINJ_ENABLE_EXTENSIONS_RESPONSE for LLRP message IMPINJ_ENABLE_EXTENSIONS_RESPONS...
Class Definition CImpinjTiltConfiguration for LLRP parameter ImpinjTiltConfiguration.
llrp_u16v_t getTID(void)
Get accessor functions for the LLRP TID field.
void setSupportsTISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTISpecs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
llrp_s32_t getZAxis(void)
Get accessor functions for the LLRP ZAxis field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getReadCount(void)
Get accessor functions for the LLRP ReadCount field.
void setRFMode(EImpinjDirectionRFMode value)
Set accessor functions for the LLRP RFMode field.
void setResult(EImpinjMarginReadResultType value)
Set accessor functions for the LLRP Result field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
CImpinjEnableRFPhaseAngle * getImpinjEnableRFPhaseAngle(void)
Get accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearImpinjArrayVersion(void)
Clears the LLRP ImpinjArrayVersion sub-parameter list.
EImpinjDirectionFieldOfView getFieldOfView(void)
Get accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEnableAntennaAttemptNotification(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaAttemptNotification field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16v_t getEnabledSectorIDs(void)
Get accessor functions for the LLRP EnabledSectorIDs field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaEventDisconnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventDisconnected field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjRFPowerSweep for LLRP parameter ImpinjRFPowerSweep.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRFDopplerFrequencyMode(EImpinjRFDopplerFrequencyMode value)
Set accessor functions for the LLRP RFDopplerFrequencyMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
Class Definition CImpinjAntennaPolarizationCapability for LLRP parameter ImpinjAntennaPolarizationCap...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
CImpinjGGASentence * getImpinjGGASentence(void)
Get accessor functions for the LLRP ImpinjGGASentence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSupportsDISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsDISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjReducedPowerMode getReducedPowerMode(void)
Get accessor functions for the LLRP ReducedPowerMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjDisabledAntennas * getImpinjDisabledAntennas(void)
Get accessor functions for the LLRP ImpinjDisabledAntennas sub-parameter.
void setResult(EImpinjGetBlockPermalockStatusResultType value)
Set accessor functions for the LLRP Result field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjTxPower for LLRP parameter ImpinjTxPower.
llrp_u16_t getUserTagPopulationLimit(void)
Get accessor functions for the LLRP UserTagPopulationLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLocationAlgorithmControl for LLRP parameter ImpinjLocationAlgorithmControl.
void setMaxNumSectors(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSectors field.
void setXAxis(llrp_s32_t value)
Set accessor functions for the LLRP XAxis field.
llrp_u8_t getFirstSeenSectorID(void)
Get accessor functions for the LLRP FirstSeenSectorID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjLISpec for LLRP parameter ImpinjLISpec.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
llrp_u1_t getEnableAntennaAttemptNotification(void)
Get accessor functions for the LLRP EnableAntennaAttemptNotification field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjBLEVersion for LLRP parameter ImpinjBLEVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSendRep(llrp_u1_t value)
Set accessor functions for the LLRP SendRep field.
EImpinjAuthenticateResultType getResult(void)
Get accessor functions for the LLRP Result field.
Class Definition CImpinjLocationReportData for LLRP parameter ImpinjLocationReportData.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLinkMonitorMode getLinkMonitorMode(void)
Get accessor functions for the LLRP LinkMonitorMode field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setTxPowerReportingMode(EImpinjTxPowerReportingModeEnum value)
Set accessor functions for the LLRP TxPowerReportingMode field.
void setGPIDebounceTimerMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPIDebounceTimerMSec field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getEnableRFPowerSweep(void)
Get accessor functions for the LLRP EnableRFPowerSweep field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFPhaseAngleMode getRFPhaseAngleMode(void)
Get accessor functions for the LLRP RFPhaseAngleMode field.
EImpinjTxPowerReportingModeEnum getTxPowerReportingMode(void)
Get accessor functions for the LLRP TxPowerReportingMode field.
Class Definition CImpinjDirectionConfig for LLRP parameter ImpinjDirectionConfig. ...
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjGetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPolarizationControl for LLRP parameter ImpinjPolarizationControl.
void setFixedFrequencyMode(EImpinjFixedFrequencyMode value)
Set accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjReportBufferConfiguration for LLRP parameter ImpinjReportBufferConfiguration...
void enrollImpinjTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Impinj into the LTKCPP registry.
llrp_u16_t getPowerLevelStepSize(void)
Get accessor functions for the LLRP PowerLevelStepSize field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnableSelectGapClose(llrp_u1_t value)
Set accessor functions for the LLRP EnableSelectGapClose field.
void setFacilityYLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityYLocationCm field.
CImpinjDirectionReporting * getImpinjDirectionReporting(void)
Get accessor functions for the LLRP ImpinjDirectionReporting sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setReadCount(llrp_u16_t value)
Set accessor functions for the LLRP ReadCount field.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaEventHysteresis for LLRP parameter ImpinjAntennaEventHysteresis.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLowDutyCycle for LLRP parameter ImpinjLowDutyCycle.
void setPhaseAngle(llrp_u16_t value)
Set accessor functions for the LLRP PhaseAngle field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode
Error result codes for LTK operations.
Definition: ltkcpp_base.h:583
EImpinjDirectionReportType getType(void)
Get accessor functions for the LLRP Type field.
void setMask(llrp_u16v_t value)
Set accessor functions for the LLRP Mask field.
std::list< CImpinjArrayVersion * >::iterator beginImpinjArrayVersion(void)
Returns the first element of the ImpinjArrayVersion sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAuthenticate for LLRP parameter ImpinjAuthenticate.
void setFacilityXLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityXLocationCm field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjTIDParity * getImpinjTIDParity(void)
Get accessor functions for the LLRP ImpinjTIDParity sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPeakRSSI for LLRP parameter ImpinjPeakRSSI.
CImpinjLocationReportData * getImpinjLocationReportData(void)
Get accessor functions for the LLRP ImpinjLocationReportData sub-parameter.
llrp_u16_t getEmptyFieldTimeout(void)
Get accessor functions for the LLRP EmptyFieldTimeout field.
void setYAxis(llrp_s32_t value)
Set accessor functions for the LLRP YAxis field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAdvancedGPOMode getGPOMode(void)
Get accessor functions for the LLRP GPOMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setRMCSentence(llrp_utf8v_t value)
Set accessor functions for the LLRP RMCSentence field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjBlockPermalockResultType value)
Set accessor functions for the LLRP Result field.
CImpinjDirectionReportData * getImpinjDirectionReportData(void)
Get accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void setZAxis(llrp_s32_t value)
Set accessor functions for the LLRP ZAxis field.
llrp_u32_t getGPOPulseDurationMSec(void)
Get accessor functions for the LLRP GPOPulseDurationMSec field.
void setReportBufferMode(EImpinjReportBufferMode value)
Set accessor functions for the LLRP ReportBufferMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjBlockWriteWordCount for LLRP parameter ImpinjBlockWriteWordCount.
void setFirstSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP FirstSeenTimestampUTC field.
void setLongitude(llrp_s32_t value)
Set accessor functions for the LLRP Longitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator beginImpinjAntennaPolarizationCapability(void)
Returns the first element of the ImpinjAntennaPolarizationCapability sub-parameter list...
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
CImpinjDirectionUserTagPopulationLimit * getImpinjDirectionUserTagPopulationLimit(void)
Get accessor functions for the LLRP ImpinjDirectionUserTagPopulationLimit sub-parameter.
Class Definition CImpinjGGASentence for LLRP parameter ImpinjGGASentence.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getSystemTagPopulationLimitHighPerformance(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
Class Definition CImpinjLocationReporting for LLRP parameter ImpinjLocationReporting.
Class Definition CImpinjDisabledAntennas for LLRP parameter ImpinjDisabledAntennas.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjRFPhaseAngle for LLRP parameter ImpinjRFPhaseAngle.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearC1G2Read(void)
Clears the LLRP C1G2Read sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s16_t getTemperature(void)
Get accessor functions for the LLRP Temperature field.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS for LLRP message IMPINJ_SAVE_SETTINGS.
void setPolarizationControlEnabled(llrp_u1_t value)
Set accessor functions for the LLRP PolarizationControlEnabled field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getGen2v2TagsOnly(void)
Get accessor functions for the LLRP Gen2v2TagsOnly field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u1_t getSendRep(void)
Get accessor functions for the LLRP SendRep field.
void setRFPhaseAngleMode(EImpinjRFPhaseAngleMode value)
Set accessor functions for the LLRP RFPhaseAngleMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setResult(EImpinjGetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjEnablePeakRSSI for LLRP parameter ImpinjEnablePeakRSSI.
Class Definition CImpinjBeaconConfiguration for LLRP parameter ImpinjBeaconConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setLinkDownThreshold(llrp_u16_t value)
Set accessor functions for the LLRP LinkDownThreshold field.
Class Definition CImpinjGPSNMEASentences for LLRP parameter ImpinjGPSNMEASentences.
Class Definition CImpinjDiagnosticReport for LLRP parameter ImpinjDiagnosticReport.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjDirectionTagPopulationStatus getTagPopulationStatus(void)
Get accessor functions for the LLRP TagPopulationStatus field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setPersistence(EImpinjQTPersistence value)
Set accessor functions for the LLRP Persistence field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocYCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
llrp_u32v_t getConfidenceData(void)
Get accessor functions for the LLRP ConfidenceData field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLowDutyCycleMode(EImpinjLowDutyCycleMode value)
Set accessor functions for the LLRP LowDutyCycleMode field.
llrp_u16v_t getMask(void)
Get accessor functions for the LLRP Mask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjIntelligentAntennaMode getManagementEnabled(void)
Get accessor functions for the LLRP ManagementEnabled field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjxArrayCapabilities for LLRP parameter ImpinjxArrayCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjBlockPermalockOpSpecResult for LLRP parameter ImpinjBlockPermalockOpSpecResul...
CImpinjRMCSentence * getImpinjRMCSentence(void)
Get accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjArrayVersion for LLRP parameter ImpinjArrayVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getMinimumPowerLevel(void)
Get accessor functions for the LLRP MinimumPowerLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjBlockPermalock for LLRP parameter ImpinjBlockPermalock.
void setBitPointer(llrp_u16_t value)
Set accessor functions for the LLRP BitPointer field.
llrp_u64_t getAntennaEventConnected(void)
Get accessor functions for the LLRP AntennaEventConnected field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
llrp_u1_t getSupportsTISpecs(void)
Get accessor functions for the LLRP SupportsTISpecs field.
Class Definition CImpinjInventorySearchMode for LLRP parameter ImpinjInventorySearchMode.
llrp_u16_t getSystemTagPopulationLimitHighSensitivity(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjSetQTConfig for LLRP parameter ImpinjSetQTConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
void setGen2v2TagsOnly(llrp_u1_t value)
Set accessor functions for the LLRP Gen2v2TagsOnly field.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
Class Definition CImpinjAuthenticateOpSpecResult for LLRP parameter ImpinjAuthenticateOpSpecResult.
void setDopplerFrequency(llrp_s16_t value)
Set accessor functions for the LLRP DopplerFrequency field.
void setEnableRFPowerSweep(llrp_u1_t value)
Set accessor functions for the LLRP EnableRFPowerSweep field.
llrp_u16v_t getPermalockStatus(void)
Get accessor functions for the LLRP PermalockStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setHeightCm(llrp_u16_t value)
Set accessor functions for the LLRP HeightCm field.
llrp_u1_t getSupportsDISpecs(void)
Get accessor functions for the LLRP SupportsDISpecs field.
void setResult(EImpinjAuthenticateResultType value)
Set accessor functions for the LLRP Result field.
void setCSI(llrp_u8_t value)
Set accessor functions for the LLRP CSI field.
llrp_u32_t getMaxNumSectors(void)
Get accessor functions for the LLRP MaxNumSectors field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setInventorySearchMode(EImpinjInventorySearchType value)
Set accessor functions for the LLRP InventorySearchMode field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjRequestedDataType getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void setControlData(llrp_u32v_t value)
Set accessor functions for the LLRP ControlData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
void setAntennaIDOffset(llrp_u16_t value)
Set accessor functions for the LLRP AntennaIDOffset field.
void setFPGAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FPGAVersion field.
void setLatitude(llrp_s32_t value)
Set accessor functions for the LLRP Latitude field.
void setRequestedData(EImpinjRequestedDataType value)
Set accessor functions for the LLRP RequestedData field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getBitLength(void)
Get accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setEnableAntDwellTimeLimit(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntDwellTimeLimit field.
Class Definition CEPCData for LLRP parameter EPCData.
llrp_u16_t getComputeWindowSeconds(void)
Get accessor functions for the LLRP ComputeWindowSeconds field.
void setType(EImpinjLocationReportType value)
Set accessor functions for the LLRP Type field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s16_t getDopplerFrequency(void)
Get accessor functions for the LLRP DopplerFrequency field.
Class Definition CImpinjTruncatedReplyConfiguration for LLRP parameter ImpinjTruncatedReplyConfigurat...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void setPowerLevelStepSize(llrp_u16_t value)
Set accessor functions for the LLRP PowerLevelStepSize field.
EImpinjMarginReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaIDOffset(void)
Get accessor functions for the LLRP AntennaIDOffset field.
void setGPOMode(EImpinjAdvancedGPOMode value)
Set accessor functions for the LLRP GPOMode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
llrp_u1v_t getMessage(void)
Get accessor functions for the LLRP Message field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
Class Definition CImpinjEnableTxPower for LLRP parameter ImpinjEnableTxPower.
llrp_u16_t getFieldPingInterval(void)
Get accessor functions for the LLRP FieldPingInterval field.
Class Definition CImpinjEnableSerializedTID for LLRP parameter ImpinjEnableSerializedTID.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
llrp_u16_t getTxPower(void)
Get accessor functions for the LLRP TxPower field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHubID(void)
Get accessor functions for the LLRP HubID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrderingMode(EImpinjAccessSpecOrderingMode value)
Set accessor functions for the LLRP OrderingMode field.
llrp_u16_t getPhaseAngle(void)
Get accessor functions for the LLRP PhaseAngle field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
CImpinjC1G2DirectionConfig * getImpinjC1G2DirectionConfig(void)
Get accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
llrp_u16_t getBlockRange(void)
Get accessor functions for the LLRP BlockRange field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator endImpinjAntennaPolarizationCapability(void)
Returns the last element of the ImpinjAntennaPolarizationCapability sub-parameter list...
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u1_t getPolarizationControlEnabled(void)
Get accessor functions for the LLRP PolarizationControlEnabled field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRSSI(llrp_s16_t value)
Set accessor functions for the LLRP RSSI field.
Class Definition CImpinjDetailedVersion for LLRP parameter ImpinjDetailedVersion. ...
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjGPSCoordinates for LLRP parameter ImpinjGPSCoordinates.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
Class Definition CImpinjReaderTemperature for LLRP parameter ImpinjReaderTemperature.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjEnableRFDopplerFrequency for LLRP parameter ImpinjEnableRFDopplerFrequency.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjHubVersions for LLRP parameter ImpinjHubVersions.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjFixedFrequencyMode getFixedFrequencyMode(void)
Get accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjOpSpecRetryCount for LLRP parameter ImpinjOpSpecRetryCount.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjxArrayDirectionCapabilities * getImpinjxArrayDirectionCapabilities(void)
Get accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getIncRepLen(void)
Get accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
void setSupportsTSISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTSISpecs field.
void setTagPopulationStatus(EImpinjDirectionTagPopulationStatus value)
Set accessor functions for the LLRP TagPopulationStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
int countEPCData(void)
Count of the LLRP EPCData sub-parameter list.
void setFrequencyList(llrp_u32v_t value)
Set accessor functions for the LLRP FrequencyList field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjDirectionReporting for LLRP parameter ImpinjDirectionReporting.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u32_t getLoopCount(void)
Get accessor functions for the LLRP LoopCount field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
llrp_u1_t getSaveConfiguration(void)
Get accessor functions for the LLRP SaveConfiguration field.
Class Definition CImpinjGetBlockPermalockStatus for LLRP parameter ImpinjGetBlockPermalockStatus.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setDiagnosticReportLevel(EImpinjDirectionDiagnosticReportLevel value)
Set accessor functions for the LLRP DiagnosticReportLevel field.
void clearEPCData(void)
Clears the LLRP EPCData sub-parameter list.
std::list< CImpinjArrayVersion * >::iterator endImpinjArrayVersion(void)
Returns the last element of the ImpinjArrayVersion sub-parameter list.
Class Definition CImpinjTIDParity for LLRP parameter ImpinjTIDParity.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjArrayVersion(void)
Count of the LLRP ImpinjArrayVersion sub-parameter list.
llrp_utf8v_t getGGASentence(void)
Get accessor functions for the LLRP GGASentence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjGetBlockPermalockStatusResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u1_t getEnableSelectGapClose(void)
Get accessor functions for the LLRP EnableSelectGapClose field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u64_t getBeaconDurationSeconds(void)
Get accessor functions for the LLRP BeaconDurationSeconds field.
void setBeaconDurationSeconds(llrp_u64_t value)
Set accessor functions for the LLRP BeaconDurationSeconds field.
void setRetryCount(llrp_u16_t value)
Set accessor functions for the LLRP RetryCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setMinimumPowerLevel(llrp_u16_t value)
Set accessor functions for the LLRP MinimumPowerLevel field.
EImpinjQTPersistence getPersistence(void)
Get accessor functions for the LLRP Persistence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
void setFault(EImpinjHubFaultType value)
Set accessor functions for the LLRP Fault field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjSerializedTIDMode getSerializedTIDMode(void)
Get accessor functions for the LLRP SerializedTIDMode field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjLocationReporting * getImpinjLocationReporting(void)
Get accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
void setComputeWindowSeconds(llrp_u16_t value)
Set accessor functions for the LLRP ComputeWindowSeconds field.
void setGGASentence(llrp_utf8v_t value)
Set accessor functions for the LLRP GGASentence field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConfidenceData(llrp_u32v_t value)
Set accessor functions for the LLRP ConfidenceData field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjAntennaAttemptEvent for LLRP parameter ImpinjAntennaAttemptEvent.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
llrp_u1_t getEnableAntDwellTimeLimit(void)
Get accessor functions for the LLRP EnableAntDwellTimeLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjEnableGPSCoordinates * getImpinjEnableGPSCoordinates(void)
Get accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrientationDegrees(llrp_s16_t value)
Set accessor functions for the LLRP OrientationDegrees field.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setHubID(llrp_u16_t value)
Set accessor functions for the LLRP HubID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableOptimizedRead * getImpinjEnableOptimizedRead(void)
Get accessor functions for the LLRP ImpinjEnableOptimizedRead sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getFPGAVersion(void)
Get accessor functions for the LLRP FPGAVersion field.
CImpinjDirectionSectors * getImpinjDirectionSectors(void)
Get accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
EImpinjRegulatoryRegion getRegulatoryRegion(void)
Get accessor functions for the LLRP RegulatoryRegion field.
Class Definition CImpinjAdvancedGPOConfiguration for LLRP parameter ImpinjAdvancedGPOConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getGPIDebounceTimerMSec(void)
Get accessor functions for the LLRP GPIDebounceTimerMSec field.
void setIncRepLen(llrp_u1_t value)
Set accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjSetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjLocationConfidence for LLRP parameter ImpinjLocationConfidence.
Class Definition CImpinjRFDopplerFrequency for LLRP parameter ImpinjRFDopplerFrequency.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUserTagPopulationLimit(llrp_u16_t value)
Set accessor functions for the LLRP UserTagPopulationLimit field.
llrp_utf8v_t getSoftwareVersion(void)
Get accessor functions for the LLRP SoftwareVersion field.
EImpinjLocationReportType getType(void)
Get accessor functions for the LLRP Type field.
void setResponse(llrp_u1v_t value)
Set accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16v_t getBlockMask(void)
Get accessor functions for the LLRP BlockMask field.
EImpinjBlockPermalockResultType getResult(void)
Get accessor functions for the LLRP Result field.
EImpinjAntennaPolarizationType getType(void)
Get accessor functions for the LLRP Type field.
Class Definition CImpinjDirectionUserTagPopulationLimit for LLRP parameter ImpinjDirectionUserTagPopu...
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getLocXCentimeters(void)
Get accessor functions for the LLRP LocXCentimeters field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaIDs(llrp_u16v_t value)
Set accessor functions for the LLRP AntennaIDs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Read * >::iterator endC1G2Read(void)
Returns the last element of the C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjSetQTConfigOpSpecResult for LLRP parameter ImpinjSetQTConfigOpSpecResult.
Class Definition CIMPINJ_ENABLE_EXTENSIONS for LLRP message IMPINJ_ENABLE_EXTENSIONS.
void setSystemTagPopulationLimitHighPerformance(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjGetQTConfig for LLRP parameter ImpinjGetQTConfig.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAccessSpecConfiguration for LLRP parameter ImpinjAccessSpecConfiguration.
Class Definition CImpinjFrequencyCapabilities for LLRP parameter ImpinjFrequencyCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnabledSectorIDs(llrp_u16v_t value)
Set accessor functions for the LLRP EnabledSectorIDs field.
void clearImpinjAntennaPolarizationCapability(void)
Clears the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
Class Definition CImpinjLinkMonitorConfiguration for LLRP parameter ImpinjLinkMonitorConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator endEPCData(void)
Returns the last element of the EPCData sub-parameter list.
CImpinjLocationConfidence * getImpinjLocationConfidence(void)
Get accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjMarginReadOpSpecResult for LLRP parameter ImpinjMarginReadOpSpecResult.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setManagementEnabled(EImpinjIntelligentAntennaMode value)
Set accessor functions for the LLRP ManagementEnabled field.
void setGPOPulseDurationMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPOPulseDurationMSec field.
Class Definition CImpinjxArrayDirectionCapabilities for LLRP parameter ImpinjxArrayDirectionCapabilit...
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaConfiguration for LLRP parameter ImpinjAntennaConfiguration.
EImpinjGPSCoordinatesMode getGPSCoordinatesMode(void)
Get accessor functions for the LLRP GPSCoordinatesMode field.
CImpinjAntennaEventConfiguration * getImpinjAntennaEventConfiguration(void)
Get accessor functions for the LLRP ImpinjAntennaEventConfiguration sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjHubConfiguration for LLRP parameter ImpinjHubConfiguration.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBitLength(llrp_u8_t value)
Set accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getSupportsTSISpecs(void)
Get accessor functions for the LLRP SupportsTSISpecs field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjReportBufferMode getReportBufferMode(void)
Get accessor functions for the LLRP ReportBufferMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getXAxis(void)
Get accessor functions for the LLRP XAxis field.
Class Definition CImpinjDirectionDiagnosticData for LLRP parameter ImpinjDirectionDiagnosticData.
void setLinkMonitorMode(EImpinjLinkMonitorMode value)
Set accessor functions for the LLRP LinkMonitorMode field.
Class Definition CImpinjEnableRFPhaseAngle for LLRP parameter ImpinjEnableRFPhaseAngle.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS_RESPONSE for LLRP message IMPINJ_SAVE_SETTINGS_RESPONSE.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_s16_t getOrientationDegrees(void)
Get accessor functions for the LLRP OrientationDegrees field.
Class Definition CImpinjExtendedTagInformation for LLRP parameter ImpinjExtendedTagInformation.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjDirectionDiagnosticReportLevel getDiagnosticReportLevel(void)
Get accessor functions for the LLRP DiagnosticReportLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFDopplerFrequencyMode getRFDopplerFrequencyMode(void)
Get accessor functions for the LLRP RFDopplerFrequencyMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
EImpinjInventorySearchType getInventorySearchMode(void)
Get accessor functions for the LLRP InventorySearchMode field.
Class Definition CImpinjGetBlockPermalockStatusOpSpecResult for LLRP parameter ImpinjGetBlockPermaloc...
CImpinjEnableSerializedTID * getImpinjEnableSerializedTID(void)
Get accessor functions for the LLRP ImpinjEnableSerializedTID sub-parameter.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
Class Definition CImpinjAntennaEventConfiguration for LLRP parameter ImpinjAntennaEventConfiguration...
CImpinjBLEVersion * getImpinjBLEVersion(void)
Get accessor functions for the LLRP ImpinjBLEVersion sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
void setSupportsLISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsLISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLocYCentimeters(void)
Get accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLastSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setRegulatoryRegion(EImpinjRegulatoryRegion value)
Set accessor functions for the LLRP RegulatoryRegion field.
void setTID(llrp_u16v_t value)
Set accessor functions for the LLRP TID field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
Class Definition CImpinjAccessSpecOrdering for LLRP parameter ImpinjAccessSpecOrdering.
Class Definition CImpinjAntennaCapabilities for LLRP parameter ImpinjAntennaCapabilities.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjSerializedTID for LLRP parameter ImpinjSerializedTID.
llrp_s32_t getFacilityXLocationCm(void)
Get accessor functions for the LLRP FacilityXLocationCm field.
void setMessage(llrp_u1v_t value)
Set accessor functions for the LLRP Message field.
Class Definition CImpinjGPIDebounceConfiguration for LLRP parameter ImpinjGPIDebounceConfiguration.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjOptimizedReadMode getOptimizedReadMode(void)
Get accessor functions for the LLRP OptimizedReadMode field.
llrp_u1_t getSupportsLISpecs(void)
Get accessor functions for the LLRP SupportsLISpecs field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableRFDopplerFrequency * getImpinjEnableRFDopplerFrequency(void)
Get accessor functions for the LLRP ImpinjEnableRFDopplerFrequency sub-parameter. ...
llrp_u8_t getEPCLength(void)
Get accessor functions for the LLRP EPCLength field.
llrp_s16_t getRSSI(void)
Get accessor functions for the LLRP RSSI field.
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
void setFirstSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP FirstSeenSectorID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjAccessSpecOrdering * getImpinjAccessSpecOrdering(void)
Get accessor functions for the LLRP ImpinjAccessSpecOrdering sub-parameter.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHeightCm(void)
Get accessor functions for the LLRP HeightCm field.
void setParityError(llrp_u1_t value)
Set accessor functions for the LLRP ParityError field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
void setOptimizedReadMode(EImpinjOptimizedReadMode value)
Set accessor functions for the LLRP OptimizedReadMode field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setType(EImpinjDirectionReportType value)
Set accessor functions for the LLRP Type field.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u32v_t getFrequencyList(void)
Get accessor functions for the LLRP FrequencyList field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator beginEPCData(void)
Returns the first element of the EPCData sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjC1G2DirectionConfig for LLRP parameter ImpinjC1G2DirectionConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void setTemperature(llrp_s16_t value)
Set accessor functions for the LLRP Temperature field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
CImpinjEnablePeakRSSI * getImpinjEnablePeakRSSI(void)
Get accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
CImpinjEnableTxPower * getImpinjEnableTxPower(void)
Get accessor functions for the LLRP ImpinjEnableTxPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
CImpinjAntennaEventHysteresis * getImpinjAntennaEventHysteresis(void)
Get accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLoopCount(llrp_u32_t value)
Set accessor functions for the LLRP LoopCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
Class Definition CImpinjReducedPowerFrequencyList for LLRP parameter ImpinjReducedPowerFrequencyList...
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjDISpec for LLRP parameter ImpinjDISpec.
void setBlockRange(llrp_u16_t value)
Set accessor functions for the LLRP BlockRange field.
void setReducedPowerMode(EImpinjReducedPowerMode value)
Set accessor functions for the LLRP ReducedPowerMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1v_t getResponse(void)
Get accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u8_t getCSI(void)
Get accessor functions for the LLRP CSI field.
Class Definition CImpinjRMCSentence for LLRP parameter ImpinjRMCSentence.
EImpinjDirectionRFMode getRFMode(void)
Get accessor functions for the LLRP RFMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjAntennaPolarizationCapability(void)
Count of the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
Class Definition CImpinjEnableGPSCoordinates for LLRP parameter ImpinjEnableGPSCoordinates.
Class Definition CImpinjMarginRead for LLRP parameter ImpinjMarginRead.
void setPeakRSSIMode(EImpinjPeakRSSIMode value)
Set accessor functions for the LLRP PeakRSSIMode field.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjC1G2LocationConfig for LLRP parameter ImpinjC1G2LocationConfig.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEPCLength(llrp_u8_t value)
Set accessor functions for the LLRP EPCLength field.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEmptyFieldTimeout(llrp_u16_t value)
Set accessor functions for the LLRP EmptyFieldTimeout field.
void setAntennaEventConnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventConnected field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjLocationAlgorithmControl * getImpinjLocationAlgorithmControl(void)
Get accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.