LTKCPP-- LLRP Toolkit C Plus Plus Library
x86/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;
115 
116 /*
117  * Vendor descriptor declarations.
118  */
119 
120 extern const CVendorDescriptor
121 g_vdescImpinj;
122 
123 
124 /*
125  * Namespace descriptor declarations.
126  */
127 
128 extern const CNamespaceDescriptor
129 g_nsdescImpinj;
130 
131 
132 /*
133  * Enumeration definitions and declarations of
134  * enumeration string tables.
135  */
136 
137 
169 enum EImpinjRequestedDataType
170 {
171 
172  ImpinjRequestedDataType_All_Capabilities = 1000,
173  ImpinjRequestedDataType_Impinj_Detailed_Version = 1001,
174  ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002,
175  ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003,
176  ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004,
177  ImpinjRequestedDataType_All_Configuration = 2000,
178  ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001,
179  ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003,
180  ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004,
181  ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005,
182  ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006,
183  ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007,
184  ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008,
185  ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009,
186  ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010,
187  ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011,
188  ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012,
189  ImpinjRequestedDataType_Impinj_Location_Configuration = 2013,
190  ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014,
191  ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015,
192  ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017,
193  ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018,
194 };
195 
196 extern const SEnumTableEntry
197 g_estImpinjRequestedDataType[];
198 
199 
241 enum EImpinjRegulatoryRegion
242 {
243 
244  ImpinjRegulatoryRegion_FCC_Part_15_247 = 0,
245  ImpinjRegulatoryRegion_ETSI_EN_300_220 = 1,
246  ImpinjRegulatoryRegion_ETSI_EN_302_208_With_LBT = 2,
247  ImpinjRegulatoryRegion_Hong_Kong_920_925_MHz = 3,
248  ImpinjRegulatoryRegion_Taiwan_922_928_MHz = 4,
249  ImpinjRegulatoryRegion_ETSI_EN_302_208_v1_2_1 = 7,
250  ImpinjRegulatoryRegion_Korea_917_921_MHz = 8,
251  ImpinjRegulatoryRegion_Malaysia_919_923_MHz = 9,
252  ImpinjRegulatoryRegion_China_920_925_MHz = 10,
253  ImpinjRegulatoryRegion_South_Africa_915_919_MHz = 12,
254  ImpinjRegulatoryRegion_Brazil_902_907_and_915_928_MHz = 13,
255  ImpinjRegulatoryRegion_Thailand_920_925_MHz = 14,
256  ImpinjRegulatoryRegion_Singapore_920_925_MHz = 15,
257  ImpinjRegulatoryRegion_Australia_920_926_MHz = 16,
258  ImpinjRegulatoryRegion_India_865_867_MHz = 17,
259  ImpinjRegulatoryRegion_Uruguay_916_928_MHz = 18,
260  ImpinjRegulatoryRegion_Vietnam_918_923_MHz = 19,
261  ImpinjRegulatoryRegion_Israel_915_917_MHz = 20,
262  ImpinjRegulatoryRegion_Philippines_918_920_MHz = 21,
263  ImpinjRegulatoryRegion_Vietnam_920_923_MHz = 22,
264  ImpinjRegulatoryRegion_Indonesia_920_923_MHz = 23,
265  ImpinjRegulatoryRegion_New_Zealand_921p5_928_MHz = 24,
266  ImpinjRegulatoryRegion_Japan_916_921_MHz_Without_LBT = 25,
267  ImpinjRegulatoryRegion_Latin_America_902_928_MHz = 26,
268  ImpinjRegulatoryRegion_Peru_916_928_MHz = 27,
269  ImpinjRegulatoryRegion_Bangladesh_925_927_MHz = 28,
270  ImpinjRegulatoryRegion_ETSI_915_921_MHz = 29,
271  ImpinjRegulatoryRegion_Morocco_867_868_MHz = 30,
272 };
273 
274 extern const SEnumTableEntry
275 g_estImpinjRegulatoryRegion[];
276 
277 
292 enum EImpinjInventorySearchType
293 {
294 
295  ImpinjInventorySearchType_Reader_Selected = 0,
296  ImpinjInventorySearchType_Single_Target = 1,
297  ImpinjInventorySearchType_Dual_Target = 2,
298  ImpinjInventorySearchType_Single_Target_With_Suppression = 3,
299  ImpinjInventorySearchType_No_Target = 4,
300  ImpinjInventorySearchType_Single_Target_BtoA = 5,
301  ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6,
302 };
303 
304 extern const SEnumTableEntry
305 g_estImpinjInventorySearchType[];
306 
307 
318 enum EImpinjFixedFrequencyMode
319 {
320 
321  ImpinjFixedFrequencyMode_Disabled = 0,
322  ImpinjFixedFrequencyMode_Auto_Select = 1,
323  ImpinjFixedFrequencyMode_Channel_List = 2,
324 };
325 
326 extern const SEnumTableEntry
327 g_estImpinjFixedFrequencyMode[];
328 
329 
339 enum EImpinjReducedPowerMode
340 {
341 
342  ImpinjReducedPowerMode_Disabled = 0,
343  ImpinjReducedPowerMode_Enabled = 1,
344 };
345 
346 extern const SEnumTableEntry
347 g_estImpinjReducedPowerMode[];
348 
349 
359 enum EImpinjLowDutyCycleMode
360 {
361 
362  ImpinjLowDutyCycleMode_Disabled = 0,
363  ImpinjLowDutyCycleMode_Enabled = 1,
364 };
365 
366 extern const SEnumTableEntry
367 g_estImpinjLowDutyCycleMode[];
368 
369 
379 enum EImpinjLinkMonitorMode
380 {
381 
382  ImpinjLinkMonitorMode_Disabled = 0,
383  ImpinjLinkMonitorMode_Enabled = 1,
384 };
385 
386 extern const SEnumTableEntry
387 g_estImpinjLinkMonitorMode[];
388 
389 
399 enum EImpinjReportBufferMode
400 {
401 
402  ImpinjReportBufferMode_Normal = 0,
403  ImpinjReportBufferMode_Low_Latency = 1,
404 };
405 
406 extern const SEnumTableEntry
407 g_estImpinjReportBufferMode[];
408 
409 
424 enum EImpinjBlockPermalockResultType
425 {
426 
427  ImpinjBlockPermalockResultType_Success = 0,
428  ImpinjBlockPermalockResultType_Insufficient_Power = 1,
429  ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2,
430  ImpinjBlockPermalockResultType_No_Response_From_Tag = 3,
431  ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4,
432  ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5,
433  ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6,
434 };
435 
436 extern const SEnumTableEntry
437 g_estImpinjBlockPermalockResultType[];
438 
439 
453 enum EImpinjGetBlockPermalockStatusResultType
454 {
455 
456  ImpinjGetBlockPermalockStatusResultType_Success = 0,
457  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1,
458  ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2,
459  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3,
460  ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4,
461  ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5,
462 };
463 
464 extern const SEnumTableEntry
465 g_estImpinjGetBlockPermalockStatusResultType[];
466 
467 
478 enum EImpinjQTDataProfile
479 {
480 
481  ImpinjQTDataProfile_Unknown = 0,
482  ImpinjQTDataProfile_Private = 1,
483  ImpinjQTDataProfile_Public = 2,
484 };
485 
486 extern const SEnumTableEntry
487 g_estImpinjQTDataProfile[];
488 
489 
500 enum EImpinjQTAccessRange
501 {
502 
503  ImpinjQTAccessRange_Unknown = 0,
504  ImpinjQTAccessRange_Normal_Range = 1,
505  ImpinjQTAccessRange_Short_Range = 2,
506 };
507 
508 extern const SEnumTableEntry
509 g_estImpinjQTAccessRange[];
510 
511 
522 enum EImpinjQTPersistence
523 {
524 
525  ImpinjQTPersistence_Unknown = 0,
526  ImpinjQTPersistence_Temporary = 1,
527  ImpinjQTPersistence_Permanent = 2,
528 };
529 
530 extern const SEnumTableEntry
531 g_estImpinjQTPersistence[];
532 
533 
547 enum EImpinjSetQTConfigResultType
548 {
549 
550  ImpinjSetQTConfigResultType_Success = 0,
551  ImpinjSetQTConfigResultType_Insufficient_Power = 1,
552  ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2,
553  ImpinjSetQTConfigResultType_No_Response_From_Tag = 3,
554  ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4,
555  ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5,
556 };
557 
558 extern const SEnumTableEntry
559 g_estImpinjSetQTConfigResultType[];
560 
561 
574 enum EImpinjGetQTConfigResultType
575 {
576 
577  ImpinjGetQTConfigResultType_Success = 0,
578  ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1,
579  ImpinjGetQTConfigResultType_No_Response_From_Tag = 2,
580  ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3,
581  ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4,
582 };
583 
584 extern const SEnumTableEntry
585 g_estImpinjGetQTConfigResultType[];
586 
587 
597 enum EImpinjSerializedTIDMode
598 {
599 
600  ImpinjSerializedTIDMode_Disabled = 0,
601  ImpinjSerializedTIDMode_Enabled = 1,
602 };
603 
604 extern const SEnumTableEntry
605 g_estImpinjSerializedTIDMode[];
606 
607 
617 enum EImpinjRFPhaseAngleMode
618 {
619 
620  ImpinjRFPhaseAngleMode_Disabled = 0,
621  ImpinjRFPhaseAngleMode_Enabled = 1,
622 };
623 
624 extern const SEnumTableEntry
625 g_estImpinjRFPhaseAngleMode[];
626 
627 
637 enum EImpinjPeakRSSIMode
638 {
639 
640  ImpinjPeakRSSIMode_Disabled = 0,
641  ImpinjPeakRSSIMode_Enabled = 1,
642 };
643 
644 extern const SEnumTableEntry
645 g_estImpinjPeakRSSIMode[];
646 
647 
657 enum EImpinjGPSCoordinatesMode
658 {
659 
660  ImpinjGPSCoordinatesMode_Disabled = 0,
661  ImpinjGPSCoordinatesMode_Enabled = 1,
662 };
663 
664 extern const SEnumTableEntry
665 g_estImpinjGPSCoordinatesMode[];
666 
667 
682 enum EImpinjAdvancedGPOMode
683 {
684 
685  ImpinjAdvancedGPOMode_Normal = 0,
686  ImpinjAdvancedGPOMode_Pulsed = 1,
687  ImpinjAdvancedGPOMode_Reader_Operational_Status = 2,
688  ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3,
689  ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4,
690  ImpinjAdvancedGPOMode_Network_Connection_Status = 5,
691  ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6,
692 };
693 
694 extern const SEnumTableEntry
695 g_estImpinjAdvancedGPOMode[];
696 
697 
707 enum EImpinjOptimizedReadMode
708 {
709 
710  ImpinjOptimizedReadMode_Disabled = 0,
711  ImpinjOptimizedReadMode_Enabled = 1,
712 };
713 
714 extern const SEnumTableEntry
715 g_estImpinjOptimizedReadMode[];
716 
717 
727 enum EImpinjAccessSpecOrderingMode
728 {
729 
730  ImpinjAccessSpecOrderingMode_FIFO = 0,
731  ImpinjAccessSpecOrderingMode_Ascending = 1,
732 };
733 
734 extern const SEnumTableEntry
735 g_estImpinjAccessSpecOrderingMode[];
736 
737 
747 enum EImpinjRFDopplerFrequencyMode
748 {
749 
750  ImpinjRFDopplerFrequencyMode_Disabled = 0,
751  ImpinjRFDopplerFrequencyMode_Enabled = 1,
752 };
753 
754 extern const SEnumTableEntry
755 g_estImpinjRFDopplerFrequencyMode[];
756 
757 
767 enum EImpinjTxPowerReportingModeEnum
768 {
769 
770  ImpinjTxPowerReportingModeEnum_Disabled = 0,
771  ImpinjTxPowerReportingModeEnum_Enabled = 1,
772 };
773 
774 extern const SEnumTableEntry
775 g_estImpinjTxPowerReportingModeEnum[];
776 
777 
788 enum EImpinjHubConnectedType
789 {
790 
791  ImpinjHubConnectedType_Unknown = 0,
792  ImpinjHubConnectedType_Disconnected = 1,
793  ImpinjHubConnectedType_Connected = 2,
794 };
795 
796 extern const SEnumTableEntry
797 g_estImpinjHubConnectedType[];
798 
799 
816 enum EImpinjHubFaultType
817 {
818 
819  ImpinjHubFaultType_No_Fault = 0,
820  ImpinjHubFaultType_RF_Power = 1,
821  ImpinjHubFaultType_RF_Power_On_Hub_1 = 2,
822  ImpinjHubFaultType_RF_Power_On_Hub_2 = 3,
823  ImpinjHubFaultType_RF_Power_On_Hub_3 = 4,
824  ImpinjHubFaultType_RF_Power_On_Hub_4 = 5,
825  ImpinjHubFaultType_No_Init = 6,
826  ImpinjHubFaultType_Serial_Overflow = 7,
827  ImpinjHubFaultType_Disconnected = 8,
828 };
829 
830 extern const SEnumTableEntry
831 g_estImpinjHubFaultType[];
832 
833 
844 enum EImpinjLocationReportType
845 {
846 
847  ImpinjLocationReportType_Entry = 0,
848  ImpinjLocationReportType_Update = 1,
849  ImpinjLocationReportType_Exit = 2,
850 };
851 
852 extern const SEnumTableEntry
853 g_estImpinjLocationReportType[];
854 
855 
899 enum EImpinjDirectionFieldOfView
900 {
901 
902  ImpinjDirectionFieldOfView_ReaderSelected = 0,
903  ImpinjDirectionFieldOfView_Wide = 1,
904  ImpinjDirectionFieldOfView_Narrow = 2,
905 };
906 
907 extern const SEnumTableEntry
908 g_estImpinjDirectionFieldOfView[];
909 
910 
945 enum EImpinjDirectionRFMode
946 {
947 
948  ImpinjDirectionRFMode_HighSensitivity = 0,
949  ImpinjDirectionRFMode_HighPerformance = 1,
950 };
951 
952 extern const SEnumTableEntry
953 g_estImpinjDirectionRFMode[];
954 
955 
1005 enum EImpinjDirectionDiagnosticReportLevel
1006 {
1007 
1008  ImpinjDirectionDiagnosticReportLevel_Off = 0,
1009  ImpinjDirectionDiagnosticReportLevel_Basic = 1,
1010  ImpinjDirectionDiagnosticReportLevel_Extended = 2,
1011  ImpinjDirectionDiagnosticReportLevel_Debug = 3,
1012 };
1013 
1014 extern const SEnumTableEntry
1015 g_estImpinjDirectionDiagnosticReportLevel[];
1016 
1017 
1056 enum EImpinjDirectionReportType
1057 {
1058 
1059  ImpinjDirectionReportType_Entry = 0,
1060  ImpinjDirectionReportType_Update = 1,
1061  ImpinjDirectionReportType_Exit = 2,
1062 };
1063 
1064 extern const SEnumTableEntry
1065 g_estImpinjDirectionReportType[];
1066 
1067 
1106 enum EImpinjDirectionTagPopulationStatus
1107 {
1108 
1109  ImpinjDirectionTagPopulationStatus_OK = 0,
1110  ImpinjDirectionTagPopulationStatus_UserOverflow = 1,
1111  ImpinjDirectionTagPopulationStatus_SystemOverflow = 2,
1112 };
1113 
1114 extern const SEnumTableEntry
1115 g_estImpinjDirectionTagPopulationStatus[];
1116 
1117 
1127 enum EImpinjIntelligentAntennaMode
1128 {
1129 
1130  ImpinjIntelligentAntennaMode_Disabled = 0,
1131  ImpinjIntelligentAntennaMode_Enabled = 1,
1132 };
1133 
1134 extern const SEnumTableEntry
1135 g_estImpinjIntelligentAntennaMode[];
1136 
1137 
1149 enum EImpinjAntennaPolarizationType
1150 {
1151 
1152  ImpinjAntennaPolarizationType_LinearHorizontal = 0,
1153  ImpinjAntennaPolarizationType_LinearVertical = 1,
1154  ImpinjAntennaPolarizationType_CircularRight = 2,
1155  ImpinjAntennaPolarizationType_CircularLeft = 3,
1156 };
1157 
1158 extern const SEnumTableEntry
1159 g_estImpinjAntennaPolarizationType[];
1160 
1161 
1178 enum EImpinjMarginReadResultType
1179 {
1180 
1181  ImpinjMarginReadResultType_Success = 0,
1182  ImpinjMarginReadResultType_Failure = 1,
1183  ImpinjMarginReadResultType_Insufficient_Power = 2,
1184  ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3,
1185  ImpinjMarginReadResultType_No_Response_From_Tag = 4,
1186  ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5,
1187  ImpinjMarginReadResultType_Incorrect_Password_Error = 6,
1188  ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7,
1189  ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8,
1190 };
1191 
1192 extern const SEnumTableEntry
1193 g_estImpinjMarginReadResultType[];
1194 
1195 
1201 
1225 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1226 {
1227  public:
1229  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1230 
1233 
1234  static const CFieldDescriptor * const
1235  s_apFieldDescriptorTable[];
1236 
1237  static const CTypeDescriptor
1238  s_typeDescriptor;
1239 
1240  void
1241  decodeFields (
1242  CDecoderStream * pDecoderStream);
1243 
1244  void
1245  assimilateSubParameters (
1246  CErrorDetails * pError);
1247 
1248  void
1249  encode (
1250  CEncoderStream * pEncoderStream) const;
1251 
1252 
1253 
1254  static CElement *
1255  s_construct (void);
1256 
1257  static void
1258  s_decodeFields (
1259  CDecoderStream * pDecoderStream,
1260  CElement * pElement);
1262 
1263 
1264 
1265  protected:
1266  std::list<CParameter *> m_listCustom;
1267 
1268  public:
1270  inline std::list<CParameter *>::iterator
1272  {
1273  return m_listCustom.begin();
1274  }
1275 
1277  inline std::list<CParameter *>::iterator
1278  endCustom (void)
1279  {
1280  return m_listCustom.end();
1281  }
1282 
1284  inline void
1286  {
1287  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1288  }
1289 
1291  inline int
1293  {
1294  return (int) (m_listCustom.size());
1295  }
1296 
1297  EResultCode
1299  addCustom (
1300  CParameter * pValue);
1301 
1302 
1303 };
1304 
1305 
1329 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1330 {
1331  public:
1334 
1337 
1338  static const CFieldDescriptor * const
1339  s_apFieldDescriptorTable[];
1340 
1341  static const CTypeDescriptor
1342  s_typeDescriptor;
1343 
1344  void
1345  decodeFields (
1346  CDecoderStream * pDecoderStream);
1347 
1348  void
1349  assimilateSubParameters (
1350  CErrorDetails * pError);
1351 
1352  void
1353  encode (
1354  CEncoderStream * pEncoderStream) const;
1355 
1356 
1357 
1358  static CElement *
1359  s_construct (void);
1360 
1361  static void
1362  s_decodeFields (
1363  CDecoderStream * pDecoderStream,
1364  CElement * pElement);
1366 
1367 
1368 
1369  protected:
1370  CLLRPStatus * m_pLLRPStatus;
1371 
1372  public:
1374  inline CLLRPStatus *
1376  {
1377  return m_pLLRPStatus;
1378  }
1379 
1381  EResultCode
1382  setLLRPStatus (
1383  CLLRPStatus * pValue);
1384 
1385 
1386  protected:
1387  std::list<CParameter *> m_listCustom;
1388 
1389  public:
1391  inline std::list<CParameter *>::iterator
1393  {
1394  return m_listCustom.begin();
1395  }
1396 
1398  inline std::list<CParameter *>::iterator
1399  endCustom (void)
1400  {
1401  return m_listCustom.end();
1402  }
1403 
1405  inline void
1407  {
1408  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1409  }
1410 
1412  inline int
1414  {
1415  return (int) (m_listCustom.size());
1416  }
1417 
1418  EResultCode
1420  addCustom (
1421  CParameter * pValue);
1422 
1423 
1424 };
1425 
1426 
1460 class CIMPINJ_SAVE_SETTINGS : public CMessage
1461 {
1462  public:
1463  CIMPINJ_SAVE_SETTINGS (void);
1464  ~CIMPINJ_SAVE_SETTINGS (void);
1465 
1468 
1469  static const CFieldDescriptor * const
1470  s_apFieldDescriptorTable[];
1471 
1472  static const CTypeDescriptor
1473  s_typeDescriptor;
1474 
1475  void
1476  decodeFields (
1477  CDecoderStream * pDecoderStream);
1478 
1479  void
1480  assimilateSubParameters (
1481  CErrorDetails * pError);
1482 
1483  void
1484  encode (
1485  CEncoderStream * pEncoderStream) const;
1486 
1487 
1488 
1489  static CElement *
1490  s_construct (void);
1491 
1492  static void
1493  s_decodeFields (
1494  CDecoderStream * pDecoderStream,
1495  CElement * pElement);
1497 
1498 
1499  protected:
1500  llrp_u1_t m_SaveConfiguration;
1501 
1504  public:
1505  static const CFieldDescriptor
1506  s_fdSaveConfiguration;
1508 
1510  inline llrp_u1_t
1512  {
1513  return m_SaveConfiguration;
1514  }
1515 
1517  inline void
1519  llrp_u1_t value)
1520  {
1521  m_SaveConfiguration = value;
1522  }
1523 
1524 
1525 
1526  protected:
1527  std::list<CParameter *> m_listCustom;
1528 
1529  public:
1531  inline std::list<CParameter *>::iterator
1533  {
1534  return m_listCustom.begin();
1535  }
1536 
1538  inline std::list<CParameter *>::iterator
1539  endCustom (void)
1540  {
1541  return m_listCustom.end();
1542  }
1543 
1545  inline void
1547  {
1548  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1549  }
1550 
1552  inline int
1554  {
1555  return (int) (m_listCustom.size());
1556  }
1557 
1558  EResultCode
1560  addCustom (
1561  CParameter * pValue);
1562 
1563 
1564 };
1565 
1566 
1590 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1591 {
1592  public:
1595 
1598 
1599  static const CFieldDescriptor * const
1600  s_apFieldDescriptorTable[];
1601 
1602  static const CTypeDescriptor
1603  s_typeDescriptor;
1604 
1605  void
1606  decodeFields (
1607  CDecoderStream * pDecoderStream);
1608 
1609  void
1610  assimilateSubParameters (
1611  CErrorDetails * pError);
1612 
1613  void
1614  encode (
1615  CEncoderStream * pEncoderStream) const;
1616 
1617 
1618 
1619  static CElement *
1620  s_construct (void);
1621 
1622  static void
1623  s_decodeFields (
1624  CDecoderStream * pDecoderStream,
1625  CElement * pElement);
1627 
1628 
1629 
1630  protected:
1631  CLLRPStatus * m_pLLRPStatus;
1632 
1633  public:
1635  inline CLLRPStatus *
1637  {
1638  return m_pLLRPStatus;
1639  }
1640 
1642  EResultCode
1643  setLLRPStatus (
1644  CLLRPStatus * pValue);
1645 
1646 
1647  protected:
1648  std::list<CParameter *> m_listCustom;
1649 
1650  public:
1652  inline std::list<CParameter *>::iterator
1654  {
1655  return m_listCustom.begin();
1656  }
1657 
1659  inline std::list<CParameter *>::iterator
1660  endCustom (void)
1661  {
1662  return m_listCustom.end();
1663  }
1664 
1666  inline void
1668  {
1669  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1670  }
1671 
1673  inline int
1675  {
1676  return (int) (m_listCustom.size());
1677  }
1678 
1679  EResultCode
1681  addCustom (
1682  CParameter * pValue);
1683 
1684 
1685 };
1686 
1687 
1695 
1718 class CImpinjRequestedData : public CParameter
1719 {
1720  public:
1721  CImpinjRequestedData (void);
1722  ~CImpinjRequestedData (void);
1723 
1726 
1727  static const CFieldDescriptor * const
1728  s_apFieldDescriptorTable[];
1729 
1730  static const CTypeDescriptor
1731  s_typeDescriptor;
1732 
1733  void
1734  decodeFields (
1735  CDecoderStream * pDecoderStream);
1736 
1737  void
1738  assimilateSubParameters (
1739  CErrorDetails * pError);
1740 
1741  void
1742  encode (
1743  CEncoderStream * pEncoderStream) const;
1744 
1745 
1746  llrp_bool_t
1747  isAllowedIn (
1748  const CTypeDescriptor * pEnclosingElementType) const;
1749 
1750 
1751  static CElement *
1752  s_construct (void);
1753 
1754  static void
1755  s_decodeFields (
1756  CDecoderStream * pDecoderStream,
1757  CElement * pElement);
1759 
1760 
1761  protected:
1762  EImpinjRequestedDataType m_eRequestedData;
1763 
1766  public:
1767  static const CFieldDescriptor
1768  s_fdRequestedData;
1770 
1772  inline EImpinjRequestedDataType
1774  {
1775  return m_eRequestedData;
1776  }
1777 
1779  inline void
1781  EImpinjRequestedDataType value)
1782  {
1783  m_eRequestedData = value;
1784  }
1785 
1786 
1787 
1788  protected:
1789  std::list<CParameter *> m_listCustom;
1790 
1791  public:
1793  inline std::list<CParameter *>::iterator
1795  {
1796  return m_listCustom.begin();
1797  }
1798 
1800  inline std::list<CParameter *>::iterator
1801  endCustom (void)
1802  {
1803  return m_listCustom.end();
1804  }
1805 
1807  inline void
1809  {
1810  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1811  }
1812 
1814  inline int
1816  {
1817  return (int) (m_listCustom.size());
1818  }
1819 
1820  EResultCode
1822  addCustom (
1823  CParameter * pValue);
1824 
1825 
1826 };
1827 
1828 
1857 class CImpinjSubRegulatoryRegion : public CParameter
1858 {
1859  public:
1862 
1865 
1866  static const CFieldDescriptor * const
1867  s_apFieldDescriptorTable[];
1868 
1869  static const CTypeDescriptor
1870  s_typeDescriptor;
1871 
1872  void
1873  decodeFields (
1874  CDecoderStream * pDecoderStream);
1875 
1876  void
1877  assimilateSubParameters (
1878  CErrorDetails * pError);
1879 
1880  void
1881  encode (
1882  CEncoderStream * pEncoderStream) const;
1883 
1884 
1885  llrp_bool_t
1886  isAllowedIn (
1887  const CTypeDescriptor * pEnclosingElementType) const;
1888 
1889 
1890  static CElement *
1891  s_construct (void);
1892 
1893  static void
1894  s_decodeFields (
1895  CDecoderStream * pDecoderStream,
1896  CElement * pElement);
1898 
1899 
1900  protected:
1901  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1902 
1905  public:
1906  static const CFieldDescriptor
1907  s_fdRegulatoryRegion;
1909 
1911  inline EImpinjRegulatoryRegion
1913  {
1914  return m_eRegulatoryRegion;
1915  }
1916 
1918  inline void
1920  EImpinjRegulatoryRegion value)
1921  {
1922  m_eRegulatoryRegion = value;
1923  }
1924 
1925 
1926 
1927  protected:
1928  std::list<CParameter *> m_listCustom;
1929 
1930  public:
1932  inline std::list<CParameter *>::iterator
1934  {
1935  return m_listCustom.begin();
1936  }
1937 
1939  inline std::list<CParameter *>::iterator
1940  endCustom (void)
1941  {
1942  return m_listCustom.end();
1943  }
1944 
1946  inline void
1948  {
1949  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1950  }
1951 
1953  inline int
1955  {
1956  return (int) (m_listCustom.size());
1957  }
1958 
1959  EResultCode
1961  addCustom (
1962  CParameter * pValue);
1963 
1964 
1965 };
1966 
1967 
1992 class CImpinjInventorySearchMode : public CParameter
1993 {
1994  public:
1997 
2000 
2001  static const CFieldDescriptor * const
2002  s_apFieldDescriptorTable[];
2003 
2004  static const CTypeDescriptor
2005  s_typeDescriptor;
2006 
2007  void
2008  decodeFields (
2009  CDecoderStream * pDecoderStream);
2010 
2011  void
2012  assimilateSubParameters (
2013  CErrorDetails * pError);
2014 
2015  void
2016  encode (
2017  CEncoderStream * pEncoderStream) const;
2018 
2019 
2020  llrp_bool_t
2021  isAllowedIn (
2022  const CTypeDescriptor * pEnclosingElementType) const;
2023 
2024 
2025  static CElement *
2026  s_construct (void);
2027 
2028  static void
2029  s_decodeFields (
2030  CDecoderStream * pDecoderStream,
2031  CElement * pElement);
2033 
2034 
2035  protected:
2036  EImpinjInventorySearchType m_eInventorySearchMode;
2037 
2040  public:
2041  static const CFieldDescriptor
2042  s_fdInventorySearchMode;
2044 
2046  inline EImpinjInventorySearchType
2048  {
2049  return m_eInventorySearchMode;
2050  }
2051 
2053  inline void
2055  EImpinjInventorySearchType value)
2056  {
2057  m_eInventorySearchMode = value;
2058  }
2059 
2060 
2061 
2062  protected:
2063  std::list<CParameter *> m_listCustom;
2064 
2065  public:
2067  inline std::list<CParameter *>::iterator
2069  {
2070  return m_listCustom.begin();
2071  }
2072 
2074  inline std::list<CParameter *>::iterator
2075  endCustom (void)
2076  {
2077  return m_listCustom.end();
2078  }
2079 
2081  inline void
2083  {
2084  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2085  }
2086 
2088  inline int
2090  {
2091  return (int) (m_listCustom.size());
2092  }
2093 
2094  EResultCode
2096  addCustom (
2097  CParameter * pValue);
2098 
2099 
2100 };
2101 
2102 
2132 class CImpinjFixedFrequencyList : public CParameter
2133 {
2134  public:
2136  ~CImpinjFixedFrequencyList (void);
2137 
2140 
2141  static const CFieldDescriptor * const
2142  s_apFieldDescriptorTable[];
2143 
2144  static const CTypeDescriptor
2145  s_typeDescriptor;
2146 
2147  void
2148  decodeFields (
2149  CDecoderStream * pDecoderStream);
2150 
2151  void
2152  assimilateSubParameters (
2153  CErrorDetails * pError);
2154 
2155  void
2156  encode (
2157  CEncoderStream * pEncoderStream) const;
2158 
2159 
2160  llrp_bool_t
2161  isAllowedIn (
2162  const CTypeDescriptor * pEnclosingElementType) const;
2163 
2164 
2165  static CElement *
2166  s_construct (void);
2167 
2168  static void
2169  s_decodeFields (
2170  CDecoderStream * pDecoderStream,
2171  CElement * pElement);
2173 
2174 
2175  protected:
2176  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
2177 
2180  public:
2181  static const CFieldDescriptor
2182  s_fdFixedFrequencyMode;
2184 
2186  inline EImpinjFixedFrequencyMode
2188  {
2189  return m_eFixedFrequencyMode;
2190  }
2191 
2193  inline void
2195  EImpinjFixedFrequencyMode value)
2196  {
2197  m_eFixedFrequencyMode = value;
2198  }
2199 
2200 
2201  protected:
2202  llrp_u16v_t m_ChannelList;
2203 
2206  public:
2207  static const CFieldDescriptor
2208  s_fdChannelList;
2210 
2212  inline llrp_u16v_t
2214  {
2215  return m_ChannelList;
2216  }
2217 
2219  inline void
2221  llrp_u16v_t value)
2222  {
2223  m_ChannelList = value;
2224  }
2225 
2226 
2227 
2228  protected:
2229  std::list<CParameter *> m_listCustom;
2230 
2231  public:
2233  inline std::list<CParameter *>::iterator
2235  {
2236  return m_listCustom.begin();
2237  }
2238 
2240  inline std::list<CParameter *>::iterator
2241  endCustom (void)
2242  {
2243  return m_listCustom.end();
2244  }
2245 
2247  inline void
2249  {
2250  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2251  }
2252 
2254  inline int
2256  {
2257  return (int) (m_listCustom.size());
2258  }
2259 
2260  EResultCode
2262  addCustom (
2263  CParameter * pValue);
2264 
2265 
2266 };
2267 
2268 
2298 class CImpinjReducedPowerFrequencyList : public CParameter
2299 {
2300  public:
2303 
2306 
2307  static const CFieldDescriptor * const
2308  s_apFieldDescriptorTable[];
2309 
2310  static const CTypeDescriptor
2311  s_typeDescriptor;
2312 
2313  void
2314  decodeFields (
2315  CDecoderStream * pDecoderStream);
2316 
2317  void
2318  assimilateSubParameters (
2319  CErrorDetails * pError);
2320 
2321  void
2322  encode (
2323  CEncoderStream * pEncoderStream) const;
2324 
2325 
2326  llrp_bool_t
2327  isAllowedIn (
2328  const CTypeDescriptor * pEnclosingElementType) const;
2329 
2330 
2331  static CElement *
2332  s_construct (void);
2333 
2334  static void
2335  s_decodeFields (
2336  CDecoderStream * pDecoderStream,
2337  CElement * pElement);
2339 
2340 
2341  protected:
2342  EImpinjReducedPowerMode m_eReducedPowerMode;
2343 
2346  public:
2347  static const CFieldDescriptor
2348  s_fdReducedPowerMode;
2350 
2352  inline EImpinjReducedPowerMode
2354  {
2355  return m_eReducedPowerMode;
2356  }
2357 
2359  inline void
2361  EImpinjReducedPowerMode value)
2362  {
2363  m_eReducedPowerMode = value;
2364  }
2365 
2366 
2367  protected:
2368  llrp_u16v_t m_ChannelList;
2369 
2372  public:
2373  static const CFieldDescriptor
2374  s_fdChannelList;
2376 
2378  inline llrp_u16v_t
2380  {
2381  return m_ChannelList;
2382  }
2383 
2385  inline void
2387  llrp_u16v_t value)
2388  {
2389  m_ChannelList = value;
2390  }
2391 
2392 
2393 
2394  protected:
2395  std::list<CParameter *> m_listCustom;
2396 
2397  public:
2399  inline std::list<CParameter *>::iterator
2401  {
2402  return m_listCustom.begin();
2403  }
2404 
2406  inline std::list<CParameter *>::iterator
2407  endCustom (void)
2408  {
2409  return m_listCustom.end();
2410  }
2411 
2413  inline void
2415  {
2416  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2417  }
2418 
2420  inline int
2422  {
2423  return (int) (m_listCustom.size());
2424  }
2425 
2426  EResultCode
2428  addCustom (
2429  CParameter * pValue);
2430 
2431 
2432 };
2433 
2434 
2464 class CImpinjLowDutyCycle : public CParameter
2465 {
2466  public:
2467  CImpinjLowDutyCycle (void);
2468  ~CImpinjLowDutyCycle (void);
2469 
2472 
2473  static const CFieldDescriptor * const
2474  s_apFieldDescriptorTable[];
2475 
2476  static const CTypeDescriptor
2477  s_typeDescriptor;
2478 
2479  void
2480  decodeFields (
2481  CDecoderStream * pDecoderStream);
2482 
2483  void
2484  assimilateSubParameters (
2485  CErrorDetails * pError);
2486 
2487  void
2488  encode (
2489  CEncoderStream * pEncoderStream) const;
2490 
2491 
2492  llrp_bool_t
2493  isAllowedIn (
2494  const CTypeDescriptor * pEnclosingElementType) const;
2495 
2496 
2497  static CElement *
2498  s_construct (void);
2499 
2500  static void
2501  s_decodeFields (
2502  CDecoderStream * pDecoderStream,
2503  CElement * pElement);
2505 
2506 
2507  protected:
2508  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2509 
2512  public:
2513  static const CFieldDescriptor
2514  s_fdLowDutyCycleMode;
2516 
2518  inline EImpinjLowDutyCycleMode
2520  {
2521  return m_eLowDutyCycleMode;
2522  }
2523 
2525  inline void
2527  EImpinjLowDutyCycleMode value)
2528  {
2529  m_eLowDutyCycleMode = value;
2530  }
2531 
2532 
2533  protected:
2534  llrp_u16_t m_EmptyFieldTimeout;
2535 
2538  public:
2539  static const CFieldDescriptor
2540  s_fdEmptyFieldTimeout;
2542 
2544  inline llrp_u16_t
2546  {
2547  return m_EmptyFieldTimeout;
2548  }
2549 
2551  inline void
2553  llrp_u16_t value)
2554  {
2555  m_EmptyFieldTimeout = value;
2556  }
2557 
2558 
2559  protected:
2560  llrp_u16_t m_FieldPingInterval;
2561 
2564  public:
2565  static const CFieldDescriptor
2566  s_fdFieldPingInterval;
2568 
2570  inline llrp_u16_t
2572  {
2573  return m_FieldPingInterval;
2574  }
2575 
2577  inline void
2579  llrp_u16_t value)
2580  {
2581  m_FieldPingInterval = value;
2582  }
2583 
2584 
2585 
2586  protected:
2587  std::list<CParameter *> m_listCustom;
2588 
2589  public:
2591  inline std::list<CParameter *>::iterator
2593  {
2594  return m_listCustom.begin();
2595  }
2596 
2598  inline std::list<CParameter *>::iterator
2599  endCustom (void)
2600  {
2601  return m_listCustom.end();
2602  }
2603 
2605  inline void
2607  {
2608  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2609  }
2610 
2612  inline int
2614  {
2615  return (int) (m_listCustom.size());
2616  }
2617 
2618  EResultCode
2620  addCustom (
2621  CParameter * pValue);
2622 
2623 
2624 };
2625 
2626 
2651 class CImpinjHubVersions : public CParameter
2652 {
2653  public:
2654  CImpinjHubVersions (void);
2655  ~CImpinjHubVersions (void);
2656 
2659 
2660  static const CFieldDescriptor * const
2661  s_apFieldDescriptorTable[];
2662 
2663  static const CTypeDescriptor
2664  s_typeDescriptor;
2665 
2666  void
2667  decodeFields (
2668  CDecoderStream * pDecoderStream);
2669 
2670  void
2671  assimilateSubParameters (
2672  CErrorDetails * pError);
2673 
2674  void
2675  encode (
2676  CEncoderStream * pEncoderStream) const;
2677 
2678 
2679  llrp_bool_t
2680  isAllowedIn (
2681  const CTypeDescriptor * pEnclosingElementType) const;
2682 
2683 
2684  static CElement *
2685  s_construct (void);
2686 
2687  static void
2688  s_decodeFields (
2689  CDecoderStream * pDecoderStream,
2690  CElement * pElement);
2692 
2693 
2694 
2695  protected:
2696  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2697 
2698  public:
2700  inline std::list<CImpinjArrayVersion *>::iterator
2702  {
2703  return m_listImpinjArrayVersion.begin();
2704  }
2705 
2707  inline std::list<CImpinjArrayVersion *>::iterator
2709  {
2710  return m_listImpinjArrayVersion.end();
2711  }
2712 
2714  inline void
2716  {
2717  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2718  }
2719 
2721  inline int
2723  {
2724  return (int) (m_listImpinjArrayVersion.size());
2725  }
2726 
2727  EResultCode
2729  addImpinjArrayVersion (
2730  CImpinjArrayVersion * pValue);
2731 
2732 
2733  protected:
2734  std::list<CParameter *> m_listCustom;
2735 
2736  public:
2738  inline std::list<CParameter *>::iterator
2740  {
2741  return m_listCustom.begin();
2742  }
2743 
2745  inline std::list<CParameter *>::iterator
2746  endCustom (void)
2747  {
2748  return m_listCustom.end();
2749  }
2750 
2752  inline void
2754  {
2755  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2756  }
2757 
2759  inline int
2761  {
2762  return (int) (m_listCustom.size());
2763  }
2764 
2765  EResultCode
2767  addCustom (
2768  CParameter * pValue);
2769 
2770 
2771 };
2772 
2773 
2806 class CImpinjDetailedVersion : public CParameter
2807 {
2808  public:
2809  CImpinjDetailedVersion (void);
2810  ~CImpinjDetailedVersion (void);
2811 
2814 
2815  static const CFieldDescriptor * const
2816  s_apFieldDescriptorTable[];
2817 
2818  static const CTypeDescriptor
2819  s_typeDescriptor;
2820 
2821  void
2822  decodeFields (
2823  CDecoderStream * pDecoderStream);
2824 
2825  void
2826  assimilateSubParameters (
2827  CErrorDetails * pError);
2828 
2829  void
2830  encode (
2831  CEncoderStream * pEncoderStream) const;
2832 
2833 
2834  llrp_bool_t
2835  isAllowedIn (
2836  const CTypeDescriptor * pEnclosingElementType) const;
2837 
2838 
2839  static CElement *
2840  s_construct (void);
2841 
2842  static void
2843  s_decodeFields (
2844  CDecoderStream * pDecoderStream,
2845  CElement * pElement);
2847 
2848 
2849  protected:
2850  llrp_utf8v_t m_ModelName;
2851 
2854  public:
2855  static const CFieldDescriptor
2856  s_fdModelName;
2858 
2860  inline llrp_utf8v_t
2862  {
2863  return m_ModelName;
2864  }
2865 
2867  inline void
2869  llrp_utf8v_t value)
2870  {
2871  m_ModelName = value;
2872  }
2873 
2874 
2875  protected:
2876  llrp_utf8v_t m_SerialNumber;
2877 
2880  public:
2881  static const CFieldDescriptor
2882  s_fdSerialNumber;
2884 
2886  inline llrp_utf8v_t
2888  {
2889  return m_SerialNumber;
2890  }
2891 
2893  inline void
2895  llrp_utf8v_t value)
2896  {
2897  m_SerialNumber = value;
2898  }
2899 
2900 
2901  protected:
2902  llrp_utf8v_t m_SoftwareVersion;
2903 
2906  public:
2907  static const CFieldDescriptor
2908  s_fdSoftwareVersion;
2910 
2912  inline llrp_utf8v_t
2914  {
2915  return m_SoftwareVersion;
2916  }
2917 
2919  inline void
2921  llrp_utf8v_t value)
2922  {
2923  m_SoftwareVersion = value;
2924  }
2925 
2926 
2927  protected:
2928  llrp_utf8v_t m_FirmwareVersion;
2929 
2932  public:
2933  static const CFieldDescriptor
2934  s_fdFirmwareVersion;
2936 
2938  inline llrp_utf8v_t
2940  {
2941  return m_FirmwareVersion;
2942  }
2943 
2945  inline void
2947  llrp_utf8v_t value)
2948  {
2949  m_FirmwareVersion = value;
2950  }
2951 
2952 
2953  protected:
2954  llrp_utf8v_t m_FPGAVersion;
2955 
2958  public:
2959  static const CFieldDescriptor
2960  s_fdFPGAVersion;
2962 
2964  inline llrp_utf8v_t
2966  {
2967  return m_FPGAVersion;
2968  }
2969 
2971  inline void
2973  llrp_utf8v_t value)
2974  {
2975  m_FPGAVersion = value;
2976  }
2977 
2978 
2979  protected:
2980  llrp_utf8v_t m_PCBAVersion;
2981 
2984  public:
2985  static const CFieldDescriptor
2986  s_fdPCBAVersion;
2988 
2990  inline llrp_utf8v_t
2992  {
2993  return m_PCBAVersion;
2994  }
2995 
2997  inline void
2999  llrp_utf8v_t value)
3000  {
3001  m_PCBAVersion = value;
3002  }
3003 
3004 
3005 
3006  protected:
3007  CImpinjHubVersions * m_pImpinjHubVersions;
3008 
3009  public:
3011  inline CImpinjHubVersions *
3013  {
3014  return m_pImpinjHubVersions;
3015  }
3016 
3018  EResultCode
3019  setImpinjHubVersions (
3020  CImpinjHubVersions * pValue);
3021 
3022 
3023  protected:
3024  CImpinjArrayVersion * m_pImpinjArrayVersion;
3025 
3026  public:
3028  inline CImpinjArrayVersion *
3030  {
3031  return m_pImpinjArrayVersion;
3032  }
3033 
3035  EResultCode
3036  setImpinjArrayVersion (
3037  CImpinjArrayVersion * pValue);
3038 
3039 
3040  protected:
3041  CImpinjBLEVersion * m_pImpinjBLEVersion;
3042 
3043  public:
3045  inline CImpinjBLEVersion *
3047  {
3048  return m_pImpinjBLEVersion;
3049  }
3050 
3052  EResultCode
3053  setImpinjBLEVersion (
3054  CImpinjBLEVersion * pValue);
3055 
3056 
3057  protected:
3058  std::list<CParameter *> m_listCustom;
3059 
3060  public:
3062  inline std::list<CParameter *>::iterator
3064  {
3065  return m_listCustom.begin();
3066  }
3067 
3069  inline std::list<CParameter *>::iterator
3070  endCustom (void)
3071  {
3072  return m_listCustom.end();
3073  }
3074 
3076  inline void
3078  {
3079  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3080  }
3081 
3083  inline int
3085  {
3086  return (int) (m_listCustom.size());
3087  }
3088 
3089  EResultCode
3091  addCustom (
3092  CParameter * pValue);
3093 
3094 
3095 };
3096 
3097 
3122 class CImpinjFrequencyCapabilities : public CParameter
3123 {
3124  public:
3127 
3130 
3131  static const CFieldDescriptor * const
3132  s_apFieldDescriptorTable[];
3133 
3134  static const CTypeDescriptor
3135  s_typeDescriptor;
3136 
3137  void
3138  decodeFields (
3139  CDecoderStream * pDecoderStream);
3140 
3141  void
3142  assimilateSubParameters (
3143  CErrorDetails * pError);
3144 
3145  void
3146  encode (
3147  CEncoderStream * pEncoderStream) const;
3148 
3149 
3150  llrp_bool_t
3151  isAllowedIn (
3152  const CTypeDescriptor * pEnclosingElementType) const;
3153 
3154 
3155  static CElement *
3156  s_construct (void);
3157 
3158  static void
3159  s_decodeFields (
3160  CDecoderStream * pDecoderStream,
3161  CElement * pElement);
3163 
3164 
3165  protected:
3166  llrp_u32v_t m_FrequencyList;
3167 
3170  public:
3171  static const CFieldDescriptor
3172  s_fdFrequencyList;
3174 
3176  inline llrp_u32v_t
3178  {
3179  return m_FrequencyList;
3180  }
3181 
3183  inline void
3185  llrp_u32v_t value)
3186  {
3187  m_FrequencyList = value;
3188  }
3189 
3190 
3191 
3192  protected:
3193  std::list<CParameter *> m_listCustom;
3194 
3195  public:
3197  inline std::list<CParameter *>::iterator
3199  {
3200  return m_listCustom.begin();
3201  }
3202 
3204  inline std::list<CParameter *>::iterator
3205  endCustom (void)
3206  {
3207  return m_listCustom.end();
3208  }
3209 
3211  inline void
3213  {
3214  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3215  }
3216 
3218  inline int
3220  {
3221  return (int) (m_listCustom.size());
3222  }
3223 
3224  EResultCode
3226  addCustom (
3227  CParameter * pValue);
3228 
3229 
3230 };
3231 
3232 
3259 class CImpinjGPIDebounceConfiguration : public CParameter
3260 {
3261  public:
3264 
3267 
3268  static const CFieldDescriptor * const
3269  s_apFieldDescriptorTable[];
3270 
3271  static const CTypeDescriptor
3272  s_typeDescriptor;
3273 
3274  void
3275  decodeFields (
3276  CDecoderStream * pDecoderStream);
3277 
3278  void
3279  assimilateSubParameters (
3280  CErrorDetails * pError);
3281 
3282  void
3283  encode (
3284  CEncoderStream * pEncoderStream) const;
3285 
3286 
3287  llrp_bool_t
3288  isAllowedIn (
3289  const CTypeDescriptor * pEnclosingElementType) const;
3290 
3291 
3292  static CElement *
3293  s_construct (void);
3294 
3295  static void
3296  s_decodeFields (
3297  CDecoderStream * pDecoderStream,
3298  CElement * pElement);
3300 
3301 
3302  protected:
3303  llrp_u16_t m_GPIPortNum;
3304 
3307  public:
3308  static const CFieldDescriptor
3309  s_fdGPIPortNum;
3311 
3313  inline llrp_u16_t
3315  {
3316  return m_GPIPortNum;
3317  }
3318 
3320  inline void
3322  llrp_u16_t value)
3323  {
3324  m_GPIPortNum = value;
3325  }
3326 
3327 
3328  protected:
3329  llrp_u32_t m_GPIDebounceTimerMSec;
3330 
3333  public:
3334  static const CFieldDescriptor
3335  s_fdGPIDebounceTimerMSec;
3337 
3339  inline llrp_u32_t
3341  {
3342  return m_GPIDebounceTimerMSec;
3343  }
3344 
3346  inline void
3348  llrp_u32_t value)
3349  {
3350  m_GPIDebounceTimerMSec = value;
3351  }
3352 
3353 
3354 
3355  protected:
3356  std::list<CParameter *> m_listCustom;
3357 
3358  public:
3360  inline std::list<CParameter *>::iterator
3362  {
3363  return m_listCustom.begin();
3364  }
3365 
3367  inline std::list<CParameter *>::iterator
3368  endCustom (void)
3369  {
3370  return m_listCustom.end();
3371  }
3372 
3374  inline void
3376  {
3377  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3378  }
3379 
3381  inline int
3383  {
3384  return (int) (m_listCustom.size());
3385  }
3386 
3387  EResultCode
3389  addCustom (
3390  CParameter * pValue);
3391 
3392 
3393 };
3394 
3395 
3420 class CImpinjReaderTemperature : public CParameter
3421 {
3422  public:
3423  CImpinjReaderTemperature (void);
3424  ~CImpinjReaderTemperature (void);
3425 
3428 
3429  static const CFieldDescriptor * const
3430  s_apFieldDescriptorTable[];
3431 
3432  static const CTypeDescriptor
3433  s_typeDescriptor;
3434 
3435  void
3436  decodeFields (
3437  CDecoderStream * pDecoderStream);
3438 
3439  void
3440  assimilateSubParameters (
3441  CErrorDetails * pError);
3442 
3443  void
3444  encode (
3445  CEncoderStream * pEncoderStream) const;
3446 
3447 
3448  llrp_bool_t
3449  isAllowedIn (
3450  const CTypeDescriptor * pEnclosingElementType) const;
3451 
3452 
3453  static CElement *
3454  s_construct (void);
3455 
3456  static void
3457  s_decodeFields (
3458  CDecoderStream * pDecoderStream,
3459  CElement * pElement);
3461 
3462 
3463  protected:
3464  llrp_s16_t m_Temperature;
3465 
3468  public:
3469  static const CFieldDescriptor
3470  s_fdTemperature;
3472 
3474  inline llrp_s16_t
3476  {
3477  return m_Temperature;
3478  }
3479 
3481  inline void
3483  llrp_s16_t value)
3484  {
3485  m_Temperature = value;
3486  }
3487 
3488 
3489 
3490  protected:
3491  std::list<CParameter *> m_listCustom;
3492 
3493  public:
3495  inline std::list<CParameter *>::iterator
3497  {
3498  return m_listCustom.begin();
3499  }
3500 
3502  inline std::list<CParameter *>::iterator
3503  endCustom (void)
3504  {
3505  return m_listCustom.end();
3506  }
3507 
3509  inline void
3511  {
3512  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3513  }
3514 
3516  inline int
3518  {
3519  return (int) (m_listCustom.size());
3520  }
3521 
3522  EResultCode
3524  addCustom (
3525  CParameter * pValue);
3526 
3527 
3528 };
3529 
3530 
3557 class CImpinjLinkMonitorConfiguration : public CParameter
3558 {
3559  public:
3562 
3565 
3566  static const CFieldDescriptor * const
3567  s_apFieldDescriptorTable[];
3568 
3569  static const CTypeDescriptor
3570  s_typeDescriptor;
3571 
3572  void
3573  decodeFields (
3574  CDecoderStream * pDecoderStream);
3575 
3576  void
3577  assimilateSubParameters (
3578  CErrorDetails * pError);
3579 
3580  void
3581  encode (
3582  CEncoderStream * pEncoderStream) const;
3583 
3584 
3585  llrp_bool_t
3586  isAllowedIn (
3587  const CTypeDescriptor * pEnclosingElementType) const;
3588 
3589 
3590  static CElement *
3591  s_construct (void);
3592 
3593  static void
3594  s_decodeFields (
3595  CDecoderStream * pDecoderStream,
3596  CElement * pElement);
3598 
3599 
3600  protected:
3601  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3602 
3605  public:
3606  static const CFieldDescriptor
3607  s_fdLinkMonitorMode;
3609 
3611  inline EImpinjLinkMonitorMode
3613  {
3614  return m_eLinkMonitorMode;
3615  }
3616 
3618  inline void
3620  EImpinjLinkMonitorMode value)
3621  {
3622  m_eLinkMonitorMode = value;
3623  }
3624 
3625 
3626  protected:
3627  llrp_u16_t m_LinkDownThreshold;
3628 
3631  public:
3632  static const CFieldDescriptor
3633  s_fdLinkDownThreshold;
3635 
3637  inline llrp_u16_t
3639  {
3640  return m_LinkDownThreshold;
3641  }
3642 
3644  inline void
3646  llrp_u16_t value)
3647  {
3648  m_LinkDownThreshold = value;
3649  }
3650 
3651 
3652 
3653  protected:
3654  std::list<CParameter *> m_listCustom;
3655 
3656  public:
3658  inline std::list<CParameter *>::iterator
3660  {
3661  return m_listCustom.begin();
3662  }
3663 
3665  inline std::list<CParameter *>::iterator
3666  endCustom (void)
3667  {
3668  return m_listCustom.end();
3669  }
3670 
3672  inline void
3674  {
3675  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3676  }
3677 
3679  inline int
3681  {
3682  return (int) (m_listCustom.size());
3683  }
3684 
3685  EResultCode
3687  addCustom (
3688  CParameter * pValue);
3689 
3690 
3691 };
3692 
3693 
3719 class CImpinjReportBufferConfiguration : public CParameter
3720 {
3721  public:
3724 
3727 
3728  static const CFieldDescriptor * const
3729  s_apFieldDescriptorTable[];
3730 
3731  static const CTypeDescriptor
3732  s_typeDescriptor;
3733 
3734  void
3735  decodeFields (
3736  CDecoderStream * pDecoderStream);
3737 
3738  void
3739  assimilateSubParameters (
3740  CErrorDetails * pError);
3741 
3742  void
3743  encode (
3744  CEncoderStream * pEncoderStream) const;
3745 
3746 
3747  llrp_bool_t
3748  isAllowedIn (
3749  const CTypeDescriptor * pEnclosingElementType) const;
3750 
3751 
3752  static CElement *
3753  s_construct (void);
3754 
3755  static void
3756  s_decodeFields (
3757  CDecoderStream * pDecoderStream,
3758  CElement * pElement);
3760 
3761 
3762  protected:
3763  EImpinjReportBufferMode m_eReportBufferMode;
3764 
3767  public:
3768  static const CFieldDescriptor
3769  s_fdReportBufferMode;
3771 
3773  inline EImpinjReportBufferMode
3775  {
3776  return m_eReportBufferMode;
3777  }
3778 
3780  inline void
3782  EImpinjReportBufferMode value)
3783  {
3784  m_eReportBufferMode = value;
3785  }
3786 
3787 
3788 
3789  protected:
3790  std::list<CParameter *> m_listCustom;
3791 
3792  public:
3794  inline std::list<CParameter *>::iterator
3796  {
3797  return m_listCustom.begin();
3798  }
3799 
3801  inline std::list<CParameter *>::iterator
3802  endCustom (void)
3803  {
3804  return m_listCustom.end();
3805  }
3806 
3808  inline void
3810  {
3811  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3812  }
3813 
3815  inline int
3817  {
3818  return (int) (m_listCustom.size());
3819  }
3820 
3821  EResultCode
3823  addCustom (
3824  CParameter * pValue);
3825 
3826 
3827 };
3828 
3829 
3858 class CImpinjAccessSpecConfiguration : public CParameter
3859 {
3860  public:
3863 
3866 
3867  static const CFieldDescriptor * const
3868  s_apFieldDescriptorTable[];
3869 
3870  static const CTypeDescriptor
3871  s_typeDescriptor;
3872 
3873  void
3874  decodeFields (
3875  CDecoderStream * pDecoderStream);
3876 
3877  void
3878  assimilateSubParameters (
3879  CErrorDetails * pError);
3880 
3881  void
3882  encode (
3883  CEncoderStream * pEncoderStream) const;
3884 
3885 
3886  llrp_bool_t
3887  isAllowedIn (
3888  const CTypeDescriptor * pEnclosingElementType) const;
3889 
3890 
3891  static CElement *
3892  s_construct (void);
3893 
3894  static void
3895  s_decodeFields (
3896  CDecoderStream * pDecoderStream,
3897  CElement * pElement);
3899 
3900 
3901 
3902  protected:
3903  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3904 
3905  public:
3909  {
3910  return m_pImpinjBlockWriteWordCount;
3911  }
3912 
3914  EResultCode
3915  setImpinjBlockWriteWordCount (
3916  CImpinjBlockWriteWordCount * pValue);
3917 
3918 
3919  protected:
3920  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3921 
3922  public:
3924  inline CImpinjOpSpecRetryCount *
3926  {
3927  return m_pImpinjOpSpecRetryCount;
3928  }
3929 
3931  EResultCode
3932  setImpinjOpSpecRetryCount (
3933  CImpinjOpSpecRetryCount * pValue);
3934 
3935 
3936  protected:
3937  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3938 
3939  public:
3941  inline CImpinjAccessSpecOrdering *
3943  {
3944  return m_pImpinjAccessSpecOrdering;
3945  }
3946 
3948  EResultCode
3949  setImpinjAccessSpecOrdering (
3950  CImpinjAccessSpecOrdering * pValue);
3951 
3952 
3953  protected:
3954  std::list<CParameter *> m_listCustom;
3955 
3956  public:
3958  inline std::list<CParameter *>::iterator
3960  {
3961  return m_listCustom.begin();
3962  }
3963 
3965  inline std::list<CParameter *>::iterator
3966  endCustom (void)
3967  {
3968  return m_listCustom.end();
3969  }
3970 
3972  inline void
3974  {
3975  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3976  }
3977 
3979  inline int
3981  {
3982  return (int) (m_listCustom.size());
3983  }
3984 
3985  EResultCode
3987  addCustom (
3988  CParameter * pValue);
3989 
3990 
3991 };
3992 
3993 
4017 class CImpinjBlockWriteWordCount : public CParameter
4018 {
4019  public:
4022 
4025 
4026  static const CFieldDescriptor * const
4027  s_apFieldDescriptorTable[];
4028 
4029  static const CTypeDescriptor
4030  s_typeDescriptor;
4031 
4032  void
4033  decodeFields (
4034  CDecoderStream * pDecoderStream);
4035 
4036  void
4037  assimilateSubParameters (
4038  CErrorDetails * pError);
4039 
4040  void
4041  encode (
4042  CEncoderStream * pEncoderStream) const;
4043 
4044 
4045  llrp_bool_t
4046  isAllowedIn (
4047  const CTypeDescriptor * pEnclosingElementType) const;
4048 
4049 
4050  static CElement *
4051  s_construct (void);
4052 
4053  static void
4054  s_decodeFields (
4055  CDecoderStream * pDecoderStream,
4056  CElement * pElement);
4058 
4059 
4060  protected:
4061  llrp_u16_t m_WordCount;
4062 
4065  public:
4066  static const CFieldDescriptor
4067  s_fdWordCount;
4069 
4071  inline llrp_u16_t
4073  {
4074  return m_WordCount;
4075  }
4076 
4078  inline void
4080  llrp_u16_t value)
4081  {
4082  m_WordCount = value;
4083  }
4084 
4085 
4086 
4087  protected:
4088  std::list<CParameter *> m_listCustom;
4089 
4090  public:
4092  inline std::list<CParameter *>::iterator
4094  {
4095  return m_listCustom.begin();
4096  }
4097 
4099  inline std::list<CParameter *>::iterator
4100  endCustom (void)
4101  {
4102  return m_listCustom.end();
4103  }
4104 
4106  inline void
4108  {
4109  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4110  }
4111 
4113  inline int
4115  {
4116  return (int) (m_listCustom.size());
4117  }
4118 
4119  EResultCode
4121  addCustom (
4122  CParameter * pValue);
4123 
4124 
4125 };
4126 
4127 
4157 class CImpinjBlockPermalock : public CParameter
4158 {
4159  public:
4160  CImpinjBlockPermalock (void);
4161  ~CImpinjBlockPermalock (void);
4162 
4165 
4166  static const CFieldDescriptor * const
4167  s_apFieldDescriptorTable[];
4168 
4169  static const CTypeDescriptor
4170  s_typeDescriptor;
4171 
4172  void
4173  decodeFields (
4174  CDecoderStream * pDecoderStream);
4175 
4176  void
4177  assimilateSubParameters (
4178  CErrorDetails * pError);
4179 
4180  void
4181  encode (
4182  CEncoderStream * pEncoderStream) const;
4183 
4184 
4185  llrp_bool_t
4186  isAllowedIn (
4187  const CTypeDescriptor * pEnclosingElementType) const;
4188 
4189 
4190  static CElement *
4191  s_construct (void);
4192 
4193  static void
4194  s_decodeFields (
4195  CDecoderStream * pDecoderStream,
4196  CElement * pElement);
4198 
4199 
4200  protected:
4201  llrp_u16_t m_OpSpecID;
4202 
4205  public:
4206  static const CFieldDescriptor
4207  s_fdOpSpecID;
4209 
4211  inline llrp_u16_t
4213  {
4214  return m_OpSpecID;
4215  }
4216 
4218  inline void
4220  llrp_u16_t value)
4221  {
4222  m_OpSpecID = value;
4223  }
4224 
4225 
4226  protected:
4227  llrp_u32_t m_AccessPassword;
4228 
4231  public:
4232  static const CFieldDescriptor
4233  s_fdAccessPassword;
4235 
4237  inline llrp_u32_t
4239  {
4240  return m_AccessPassword;
4241  }
4242 
4244  inline void
4246  llrp_u32_t value)
4247  {
4248  m_AccessPassword = value;
4249  }
4250 
4251 
4252  protected:
4253  llrp_u2_t m_MB;
4254 
4257  public:
4258  static const CFieldDescriptor
4259  s_fdMB;
4261 
4263  inline llrp_u2_t
4264  getMB (void)
4265  {
4266  return m_MB;
4267  }
4268 
4270  inline void
4272  llrp_u2_t value)
4273  {
4274  m_MB = value;
4275  }
4276 
4277 
4278  protected:
4279  llrp_u16_t m_BlockPointer;
4280 
4283  public:
4284  static const CFieldDescriptor
4285  s_fdBlockPointer;
4287 
4289  inline llrp_u16_t
4291  {
4292  return m_BlockPointer;
4293  }
4294 
4296  inline void
4298  llrp_u16_t value)
4299  {
4300  m_BlockPointer = value;
4301  }
4302 
4303 
4304  protected:
4305  llrp_u16v_t m_BlockMask;
4306 
4309  public:
4310  static const CFieldDescriptor
4311  s_fdBlockMask;
4313 
4315  inline llrp_u16v_t
4317  {
4318  return m_BlockMask;
4319  }
4320 
4322  inline void
4324  llrp_u16v_t value)
4325  {
4326  m_BlockMask = value;
4327  }
4328 
4329 
4330 
4331  protected:
4332  std::list<CParameter *> m_listCustom;
4333 
4334  public:
4336  inline std::list<CParameter *>::iterator
4338  {
4339  return m_listCustom.begin();
4340  }
4341 
4343  inline std::list<CParameter *>::iterator
4344  endCustom (void)
4345  {
4346  return m_listCustom.end();
4347  }
4348 
4350  inline void
4352  {
4353  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4354  }
4355 
4357  inline int
4359  {
4360  return (int) (m_listCustom.size());
4361  }
4362 
4363  EResultCode
4365  addCustom (
4366  CParameter * pValue);
4367 
4368 
4369 };
4370 
4371 
4397 class CImpinjBlockPermalockOpSpecResult : public CParameter
4398 {
4399  public:
4402 
4405 
4406  static const CFieldDescriptor * const
4407  s_apFieldDescriptorTable[];
4408 
4409  static const CTypeDescriptor
4410  s_typeDescriptor;
4411 
4412  void
4413  decodeFields (
4414  CDecoderStream * pDecoderStream);
4415 
4416  void
4417  assimilateSubParameters (
4418  CErrorDetails * pError);
4419 
4420  void
4421  encode (
4422  CEncoderStream * pEncoderStream) const;
4423 
4424 
4425  llrp_bool_t
4426  isAllowedIn (
4427  const CTypeDescriptor * pEnclosingElementType) const;
4428 
4429 
4430  static CElement *
4431  s_construct (void);
4432 
4433  static void
4434  s_decodeFields (
4435  CDecoderStream * pDecoderStream,
4436  CElement * pElement);
4438 
4439 
4440  protected:
4441  EImpinjBlockPermalockResultType m_eResult;
4442 
4445  public:
4446  static const CFieldDescriptor
4447  s_fdResult;
4449 
4451  inline EImpinjBlockPermalockResultType
4452  getResult (void)
4453  {
4454  return m_eResult;
4455  }
4456 
4458  inline void
4460  EImpinjBlockPermalockResultType value)
4461  {
4462  m_eResult = value;
4463  }
4464 
4465 
4466  protected:
4467  llrp_u16_t m_OpSpecID;
4468 
4471  public:
4472  static const CFieldDescriptor
4473  s_fdOpSpecID;
4475 
4477  inline llrp_u16_t
4479  {
4480  return m_OpSpecID;
4481  }
4482 
4484  inline void
4486  llrp_u16_t value)
4487  {
4488  m_OpSpecID = value;
4489  }
4490 
4491 
4492 
4493  protected:
4494  std::list<CParameter *> m_listCustom;
4495 
4496  public:
4498  inline std::list<CParameter *>::iterator
4500  {
4501  return m_listCustom.begin();
4502  }
4503 
4505  inline std::list<CParameter *>::iterator
4506  endCustom (void)
4507  {
4508  return m_listCustom.end();
4509  }
4510 
4512  inline void
4514  {
4515  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4516  }
4517 
4519  inline int
4521  {
4522  return (int) (m_listCustom.size());
4523  }
4524 
4525  EResultCode
4527  addCustom (
4528  CParameter * pValue);
4529 
4530 
4531 };
4532 
4533 
4563 class CImpinjGetBlockPermalockStatus : public CParameter
4564 {
4565  public:
4568 
4571 
4572  static const CFieldDescriptor * const
4573  s_apFieldDescriptorTable[];
4574 
4575  static const CTypeDescriptor
4576  s_typeDescriptor;
4577 
4578  void
4579  decodeFields (
4580  CDecoderStream * pDecoderStream);
4581 
4582  void
4583  assimilateSubParameters (
4584  CErrorDetails * pError);
4585 
4586  void
4587  encode (
4588  CEncoderStream * pEncoderStream) const;
4589 
4590 
4591  llrp_bool_t
4592  isAllowedIn (
4593  const CTypeDescriptor * pEnclosingElementType) const;
4594 
4595 
4596  static CElement *
4597  s_construct (void);
4598 
4599  static void
4600  s_decodeFields (
4601  CDecoderStream * pDecoderStream,
4602  CElement * pElement);
4604 
4605 
4606  protected:
4607  llrp_u16_t m_OpSpecID;
4608 
4611  public:
4612  static const CFieldDescriptor
4613  s_fdOpSpecID;
4615 
4617  inline llrp_u16_t
4619  {
4620  return m_OpSpecID;
4621  }
4622 
4624  inline void
4626  llrp_u16_t value)
4627  {
4628  m_OpSpecID = value;
4629  }
4630 
4631 
4632  protected:
4633  llrp_u32_t m_AccessPassword;
4634 
4637  public:
4638  static const CFieldDescriptor
4639  s_fdAccessPassword;
4641 
4643  inline llrp_u32_t
4645  {
4646  return m_AccessPassword;
4647  }
4648 
4650  inline void
4652  llrp_u32_t value)
4653  {
4654  m_AccessPassword = value;
4655  }
4656 
4657 
4658  protected:
4659  llrp_u2_t m_MB;
4660 
4663  public:
4664  static const CFieldDescriptor
4665  s_fdMB;
4667 
4669  inline llrp_u2_t
4670  getMB (void)
4671  {
4672  return m_MB;
4673  }
4674 
4676  inline void
4678  llrp_u2_t value)
4679  {
4680  m_MB = value;
4681  }
4682 
4683 
4684  protected:
4685  llrp_u16_t m_BlockPointer;
4686 
4689  public:
4690  static const CFieldDescriptor
4691  s_fdBlockPointer;
4693 
4695  inline llrp_u16_t
4697  {
4698  return m_BlockPointer;
4699  }
4700 
4702  inline void
4704  llrp_u16_t value)
4705  {
4706  m_BlockPointer = value;
4707  }
4708 
4709 
4710  protected:
4711  llrp_u16_t m_BlockRange;
4712 
4715  public:
4716  static const CFieldDescriptor
4717  s_fdBlockRange;
4719 
4721  inline llrp_u16_t
4723  {
4724  return m_BlockRange;
4725  }
4726 
4728  inline void
4730  llrp_u16_t value)
4731  {
4732  m_BlockRange = value;
4733  }
4734 
4735 
4736 
4737  protected:
4738  std::list<CParameter *> m_listCustom;
4739 
4740  public:
4742  inline std::list<CParameter *>::iterator
4744  {
4745  return m_listCustom.begin();
4746  }
4747 
4749  inline std::list<CParameter *>::iterator
4750  endCustom (void)
4751  {
4752  return m_listCustom.end();
4753  }
4754 
4756  inline void
4758  {
4759  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4760  }
4761 
4763  inline int
4765  {
4766  return (int) (m_listCustom.size());
4767  }
4768 
4769  EResultCode
4771  addCustom (
4772  CParameter * pValue);
4773 
4774 
4775 };
4776 
4777 
4804 class CImpinjGetBlockPermalockStatusOpSpecResult : public CParameter
4805 {
4806  public:
4809 
4812 
4813  static const CFieldDescriptor * const
4814  s_apFieldDescriptorTable[];
4815 
4816  static const CTypeDescriptor
4817  s_typeDescriptor;
4818 
4819  void
4820  decodeFields (
4821  CDecoderStream * pDecoderStream);
4822 
4823  void
4824  assimilateSubParameters (
4825  CErrorDetails * pError);
4826 
4827  void
4828  encode (
4829  CEncoderStream * pEncoderStream) const;
4830 
4831 
4832  llrp_bool_t
4833  isAllowedIn (
4834  const CTypeDescriptor * pEnclosingElementType) const;
4835 
4836 
4837  static CElement *
4838  s_construct (void);
4839 
4840  static void
4841  s_decodeFields (
4842  CDecoderStream * pDecoderStream,
4843  CElement * pElement);
4845 
4846 
4847  protected:
4848  EImpinjGetBlockPermalockStatusResultType m_eResult;
4849 
4852  public:
4853  static const CFieldDescriptor
4854  s_fdResult;
4856 
4858  inline EImpinjGetBlockPermalockStatusResultType
4859  getResult (void)
4860  {
4861  return m_eResult;
4862  }
4863 
4865  inline void
4867  EImpinjGetBlockPermalockStatusResultType value)
4868  {
4869  m_eResult = value;
4870  }
4871 
4872 
4873  protected:
4874  llrp_u16_t m_OpSpecID;
4875 
4878  public:
4879  static const CFieldDescriptor
4880  s_fdOpSpecID;
4882 
4884  inline llrp_u16_t
4886  {
4887  return m_OpSpecID;
4888  }
4889 
4891  inline void
4893  llrp_u16_t value)
4894  {
4895  m_OpSpecID = value;
4896  }
4897 
4898 
4899  protected:
4900  llrp_u16v_t m_PermalockStatus;
4901 
4904  public:
4905  static const CFieldDescriptor
4906  s_fdPermalockStatus;
4908 
4910  inline llrp_u16v_t
4912  {
4913  return m_PermalockStatus;
4914  }
4915 
4917  inline void
4919  llrp_u16v_t value)
4920  {
4921  m_PermalockStatus = value;
4922  }
4923 
4924 
4925 
4926  protected:
4927  std::list<CParameter *> m_listCustom;
4928 
4929  public:
4931  inline std::list<CParameter *>::iterator
4933  {
4934  return m_listCustom.begin();
4935  }
4936 
4938  inline std::list<CParameter *>::iterator
4939  endCustom (void)
4940  {
4941  return m_listCustom.end();
4942  }
4943 
4945  inline void
4947  {
4948  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4949  }
4950 
4952  inline int
4954  {
4955  return (int) (m_listCustom.size());
4956  }
4957 
4958  EResultCode
4960  addCustom (
4961  CParameter * pValue);
4962 
4963 
4964 };
4965 
4966 
4996 class CImpinjSetQTConfig : public CParameter
4997 {
4998  public:
4999  CImpinjSetQTConfig (void);
5000  ~CImpinjSetQTConfig (void);
5001 
5004 
5005  static const CFieldDescriptor * const
5006  s_apFieldDescriptorTable[];
5007 
5008  static const CTypeDescriptor
5009  s_typeDescriptor;
5010 
5011  void
5012  decodeFields (
5013  CDecoderStream * pDecoderStream);
5014 
5015  void
5016  assimilateSubParameters (
5017  CErrorDetails * pError);
5018 
5019  void
5020  encode (
5021  CEncoderStream * pEncoderStream) const;
5022 
5023 
5024  llrp_bool_t
5025  isAllowedIn (
5026  const CTypeDescriptor * pEnclosingElementType) const;
5027 
5028 
5029  static CElement *
5030  s_construct (void);
5031 
5032  static void
5033  s_decodeFields (
5034  CDecoderStream * pDecoderStream,
5035  CElement * pElement);
5037 
5038 
5039  protected:
5040  llrp_u16_t m_OpSpecID;
5041 
5044  public:
5045  static const CFieldDescriptor
5046  s_fdOpSpecID;
5048 
5050  inline llrp_u16_t
5052  {
5053  return m_OpSpecID;
5054  }
5055 
5057  inline void
5059  llrp_u16_t value)
5060  {
5061  m_OpSpecID = value;
5062  }
5063 
5064 
5065  protected:
5066  llrp_u32_t m_AccessPassword;
5067 
5070  public:
5071  static const CFieldDescriptor
5072  s_fdAccessPassword;
5074 
5076  inline llrp_u32_t
5078  {
5079  return m_AccessPassword;
5080  }
5081 
5083  inline void
5085  llrp_u32_t value)
5086  {
5087  m_AccessPassword = value;
5088  }
5089 
5090 
5091  protected:
5092  EImpinjQTDataProfile m_eDataProfile;
5093 
5096  public:
5097  static const CFieldDescriptor
5098  s_fdDataProfile;
5100 
5102  inline EImpinjQTDataProfile
5104  {
5105  return m_eDataProfile;
5106  }
5107 
5109  inline void
5111  EImpinjQTDataProfile value)
5112  {
5113  m_eDataProfile = value;
5114  }
5115 
5116 
5117  protected:
5118  EImpinjQTAccessRange m_eAccessRange;
5119 
5122  public:
5123  static const CFieldDescriptor
5124  s_fdAccessRange;
5126 
5128  inline EImpinjQTAccessRange
5130  {
5131  return m_eAccessRange;
5132  }
5133 
5135  inline void
5137  EImpinjQTAccessRange value)
5138  {
5139  m_eAccessRange = value;
5140  }
5141 
5142 
5143  protected:
5144  EImpinjQTPersistence m_ePersistence;
5145 
5148  public:
5149  static const CFieldDescriptor
5150  s_fdPersistence;
5152 
5154  inline EImpinjQTPersistence
5156  {
5157  return m_ePersistence;
5158  }
5159 
5161  inline void
5163  EImpinjQTPersistence value)
5164  {
5165  m_ePersistence = value;
5166  }
5167 
5168 
5169 
5170  protected:
5171  std::list<CParameter *> m_listCustom;
5172 
5173  public:
5175  inline std::list<CParameter *>::iterator
5177  {
5178  return m_listCustom.begin();
5179  }
5180 
5182  inline std::list<CParameter *>::iterator
5183  endCustom (void)
5184  {
5185  return m_listCustom.end();
5186  }
5187 
5189  inline void
5191  {
5192  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5193  }
5194 
5196  inline int
5198  {
5199  return (int) (m_listCustom.size());
5200  }
5201 
5202  EResultCode
5204  addCustom (
5205  CParameter * pValue);
5206 
5207 
5208 };
5209 
5210 
5236 class CImpinjSetQTConfigOpSpecResult : public CParameter
5237 {
5238  public:
5241 
5244 
5245  static const CFieldDescriptor * const
5246  s_apFieldDescriptorTable[];
5247 
5248  static const CTypeDescriptor
5249  s_typeDescriptor;
5250 
5251  void
5252  decodeFields (
5253  CDecoderStream * pDecoderStream);
5254 
5255  void
5256  assimilateSubParameters (
5257  CErrorDetails * pError);
5258 
5259  void
5260  encode (
5261  CEncoderStream * pEncoderStream) const;
5262 
5263 
5264  llrp_bool_t
5265  isAllowedIn (
5266  const CTypeDescriptor * pEnclosingElementType) const;
5267 
5268 
5269  static CElement *
5270  s_construct (void);
5271 
5272  static void
5273  s_decodeFields (
5274  CDecoderStream * pDecoderStream,
5275  CElement * pElement);
5277 
5278 
5279  protected:
5280  EImpinjSetQTConfigResultType m_eResult;
5281 
5284  public:
5285  static const CFieldDescriptor
5286  s_fdResult;
5288 
5290  inline EImpinjSetQTConfigResultType
5291  getResult (void)
5292  {
5293  return m_eResult;
5294  }
5295 
5297  inline void
5299  EImpinjSetQTConfigResultType value)
5300  {
5301  m_eResult = value;
5302  }
5303 
5304 
5305  protected:
5306  llrp_u16_t m_OpSpecID;
5307 
5310  public:
5311  static const CFieldDescriptor
5312  s_fdOpSpecID;
5314 
5316  inline llrp_u16_t
5318  {
5319  return m_OpSpecID;
5320  }
5321 
5323  inline void
5325  llrp_u16_t value)
5326  {
5327  m_OpSpecID = value;
5328  }
5329 
5330 
5331 
5332  protected:
5333  std::list<CParameter *> m_listCustom;
5334 
5335  public:
5337  inline std::list<CParameter *>::iterator
5339  {
5340  return m_listCustom.begin();
5341  }
5342 
5344  inline std::list<CParameter *>::iterator
5345  endCustom (void)
5346  {
5347  return m_listCustom.end();
5348  }
5349 
5351  inline void
5353  {
5354  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5355  }
5356 
5358  inline int
5360  {
5361  return (int) (m_listCustom.size());
5362  }
5363 
5364  EResultCode
5366  addCustom (
5367  CParameter * pValue);
5368 
5369 
5370 };
5371 
5372 
5398 class CImpinjGetQTConfig : public CParameter
5399 {
5400  public:
5401  CImpinjGetQTConfig (void);
5402  ~CImpinjGetQTConfig (void);
5403 
5406 
5407  static const CFieldDescriptor * const
5408  s_apFieldDescriptorTable[];
5409 
5410  static const CTypeDescriptor
5411  s_typeDescriptor;
5412 
5413  void
5414  decodeFields (
5415  CDecoderStream * pDecoderStream);
5416 
5417  void
5418  assimilateSubParameters (
5419  CErrorDetails * pError);
5420 
5421  void
5422  encode (
5423  CEncoderStream * pEncoderStream) const;
5424 
5425 
5426  llrp_bool_t
5427  isAllowedIn (
5428  const CTypeDescriptor * pEnclosingElementType) const;
5429 
5430 
5431  static CElement *
5432  s_construct (void);
5433 
5434  static void
5435  s_decodeFields (
5436  CDecoderStream * pDecoderStream,
5437  CElement * pElement);
5439 
5440 
5441  protected:
5442  llrp_u16_t m_OpSpecID;
5443 
5446  public:
5447  static const CFieldDescriptor
5448  s_fdOpSpecID;
5450 
5452  inline llrp_u16_t
5454  {
5455  return m_OpSpecID;
5456  }
5457 
5459  inline void
5461  llrp_u16_t value)
5462  {
5463  m_OpSpecID = value;
5464  }
5465 
5466 
5467  protected:
5468  llrp_u32_t m_AccessPassword;
5469 
5472  public:
5473  static const CFieldDescriptor
5474  s_fdAccessPassword;
5476 
5478  inline llrp_u32_t
5480  {
5481  return m_AccessPassword;
5482  }
5483 
5485  inline void
5487  llrp_u32_t value)
5488  {
5489  m_AccessPassword = value;
5490  }
5491 
5492 
5493 
5494  protected:
5495  std::list<CParameter *> m_listCustom;
5496 
5497  public:
5499  inline std::list<CParameter *>::iterator
5501  {
5502  return m_listCustom.begin();
5503  }
5504 
5506  inline std::list<CParameter *>::iterator
5507  endCustom (void)
5508  {
5509  return m_listCustom.end();
5510  }
5511 
5513  inline void
5515  {
5516  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5517  }
5518 
5520  inline int
5522  {
5523  return (int) (m_listCustom.size());
5524  }
5525 
5526  EResultCode
5528  addCustom (
5529  CParameter * pValue);
5530 
5531 
5532 };
5533 
5534 
5563 class CImpinjGetQTConfigOpSpecResult : public CParameter
5564 {
5565  public:
5568 
5571 
5572  static const CFieldDescriptor * const
5573  s_apFieldDescriptorTable[];
5574 
5575  static const CTypeDescriptor
5576  s_typeDescriptor;
5577 
5578  void
5579  decodeFields (
5580  CDecoderStream * pDecoderStream);
5581 
5582  void
5583  assimilateSubParameters (
5584  CErrorDetails * pError);
5585 
5586  void
5587  encode (
5588  CEncoderStream * pEncoderStream) const;
5589 
5590 
5591  llrp_bool_t
5592  isAllowedIn (
5593  const CTypeDescriptor * pEnclosingElementType) const;
5594 
5595 
5596  static CElement *
5597  s_construct (void);
5598 
5599  static void
5600  s_decodeFields (
5601  CDecoderStream * pDecoderStream,
5602  CElement * pElement);
5604 
5605 
5606  protected:
5607  EImpinjGetQTConfigResultType m_eResult;
5608 
5611  public:
5612  static const CFieldDescriptor
5613  s_fdResult;
5615 
5617  inline EImpinjGetQTConfigResultType
5618  getResult (void)
5619  {
5620  return m_eResult;
5621  }
5622 
5624  inline void
5626  EImpinjGetQTConfigResultType value)
5627  {
5628  m_eResult = value;
5629  }
5630 
5631 
5632  protected:
5633  llrp_u16_t m_OpSpecID;
5634 
5637  public:
5638  static const CFieldDescriptor
5639  s_fdOpSpecID;
5641 
5643  inline llrp_u16_t
5645  {
5646  return m_OpSpecID;
5647  }
5648 
5650  inline void
5652  llrp_u16_t value)
5653  {
5654  m_OpSpecID = value;
5655  }
5656 
5657 
5658  protected:
5659  EImpinjQTDataProfile m_eDataProfile;
5660 
5663  public:
5664  static const CFieldDescriptor
5665  s_fdDataProfile;
5667 
5669  inline EImpinjQTDataProfile
5671  {
5672  return m_eDataProfile;
5673  }
5674 
5676  inline void
5678  EImpinjQTDataProfile value)
5679  {
5680  m_eDataProfile = value;
5681  }
5682 
5683 
5684  protected:
5685  EImpinjQTAccessRange m_eAccessRange;
5686 
5689  public:
5690  static const CFieldDescriptor
5691  s_fdAccessRange;
5693 
5695  inline EImpinjQTAccessRange
5697  {
5698  return m_eAccessRange;
5699  }
5700 
5702  inline void
5704  EImpinjQTAccessRange value)
5705  {
5706  m_eAccessRange = value;
5707  }
5708 
5709 
5710 
5711  protected:
5712  std::list<CParameter *> m_listCustom;
5713 
5714  public:
5716  inline std::list<CParameter *>::iterator
5718  {
5719  return m_listCustom.begin();
5720  }
5721 
5723  inline std::list<CParameter *>::iterator
5724  endCustom (void)
5725  {
5726  return m_listCustom.end();
5727  }
5728 
5730  inline void
5732  {
5733  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5734  }
5735 
5737  inline int
5739  {
5740  return (int) (m_listCustom.size());
5741  }
5742 
5743  EResultCode
5745  addCustom (
5746  CParameter * pValue);
5747 
5748 
5749 };
5750 
5751 
5782 class CImpinjTagReportContentSelector : public CParameter
5783 {
5784  public:
5787 
5790 
5791  static const CFieldDescriptor * const
5792  s_apFieldDescriptorTable[];
5793 
5794  static const CTypeDescriptor
5795  s_typeDescriptor;
5796 
5797  void
5798  decodeFields (
5799  CDecoderStream * pDecoderStream);
5800 
5801  void
5802  assimilateSubParameters (
5803  CErrorDetails * pError);
5804 
5805  void
5806  encode (
5807  CEncoderStream * pEncoderStream) const;
5808 
5809 
5810  llrp_bool_t
5811  isAllowedIn (
5812  const CTypeDescriptor * pEnclosingElementType) const;
5813 
5814 
5815  static CElement *
5816  s_construct (void);
5817 
5818  static void
5819  s_decodeFields (
5820  CDecoderStream * pDecoderStream,
5821  CElement * pElement);
5823 
5824 
5825 
5826  protected:
5827  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5828 
5829  public:
5833  {
5834  return m_pImpinjEnableSerializedTID;
5835  }
5836 
5838  EResultCode
5839  setImpinjEnableSerializedTID (
5840  CImpinjEnableSerializedTID * pValue);
5841 
5842 
5843  protected:
5844  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5845 
5846  public:
5848  inline CImpinjEnableRFPhaseAngle *
5850  {
5851  return m_pImpinjEnableRFPhaseAngle;
5852  }
5853 
5855  EResultCode
5856  setImpinjEnableRFPhaseAngle (
5857  CImpinjEnableRFPhaseAngle * pValue);
5858 
5859 
5860  protected:
5861  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5862 
5863  public:
5865  inline CImpinjEnablePeakRSSI *
5867  {
5868  return m_pImpinjEnablePeakRSSI;
5869  }
5870 
5872  EResultCode
5873  setImpinjEnablePeakRSSI (
5874  CImpinjEnablePeakRSSI * pValue);
5875 
5876 
5877  protected:
5878  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5879 
5880  public:
5884  {
5885  return m_pImpinjEnableGPSCoordinates;
5886  }
5887 
5889  EResultCode
5890  setImpinjEnableGPSCoordinates (
5891  CImpinjEnableGPSCoordinates * pValue);
5892 
5893 
5894  protected:
5895  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5896 
5897  public:
5901  {
5902  return m_pImpinjEnableOptimizedRead;
5903  }
5904 
5906  EResultCode
5907  setImpinjEnableOptimizedRead (
5908  CImpinjEnableOptimizedRead * pValue);
5909 
5910 
5911  protected:
5912  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5913 
5914  public:
5918  {
5919  return m_pImpinjEnableRFDopplerFrequency;
5920  }
5921 
5923  EResultCode
5924  setImpinjEnableRFDopplerFrequency (
5926 
5927 
5928  protected:
5929  CImpinjEnableTxPower * m_pImpinjEnableTxPower;
5930 
5931  public:
5933  inline CImpinjEnableTxPower *
5935  {
5936  return m_pImpinjEnableTxPower;
5937  }
5938 
5940  EResultCode
5941  setImpinjEnableTxPower (
5942  CImpinjEnableTxPower * pValue);
5943 
5944 
5945  protected:
5946  std::list<CParameter *> m_listCustom;
5947 
5948  public:
5950  inline std::list<CParameter *>::iterator
5952  {
5953  return m_listCustom.begin();
5954  }
5955 
5957  inline std::list<CParameter *>::iterator
5958  endCustom (void)
5959  {
5960  return m_listCustom.end();
5961  }
5962 
5964  inline void
5966  {
5967  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5968  }
5969 
5971  inline int
5973  {
5974  return (int) (m_listCustom.size());
5975  }
5976 
5977  EResultCode
5979  addCustom (
5980  CParameter * pValue);
5981 
5982 
5983 };
5984 
5985 
6009 class CImpinjEnableSerializedTID : public CParameter
6010 {
6011  public:
6014 
6017 
6018  static const CFieldDescriptor * const
6019  s_apFieldDescriptorTable[];
6020 
6021  static const CTypeDescriptor
6022  s_typeDescriptor;
6023 
6024  void
6025  decodeFields (
6026  CDecoderStream * pDecoderStream);
6027 
6028  void
6029  assimilateSubParameters (
6030  CErrorDetails * pError);
6031 
6032  void
6033  encode (
6034  CEncoderStream * pEncoderStream) const;
6035 
6036 
6037  llrp_bool_t
6038  isAllowedIn (
6039  const CTypeDescriptor * pEnclosingElementType) const;
6040 
6041 
6042  static CElement *
6043  s_construct (void);
6044 
6045  static void
6046  s_decodeFields (
6047  CDecoderStream * pDecoderStream,
6048  CElement * pElement);
6050 
6051 
6052  protected:
6053  EImpinjSerializedTIDMode m_eSerializedTIDMode;
6054 
6057  public:
6058  static const CFieldDescriptor
6059  s_fdSerializedTIDMode;
6061 
6063  inline EImpinjSerializedTIDMode
6065  {
6066  return m_eSerializedTIDMode;
6067  }
6068 
6070  inline void
6072  EImpinjSerializedTIDMode value)
6073  {
6074  m_eSerializedTIDMode = value;
6075  }
6076 
6077 
6078 
6079  protected:
6080  std::list<CParameter *> m_listCustom;
6081 
6082  public:
6084  inline std::list<CParameter *>::iterator
6086  {
6087  return m_listCustom.begin();
6088  }
6089 
6091  inline std::list<CParameter *>::iterator
6092  endCustom (void)
6093  {
6094  return m_listCustom.end();
6095  }
6096 
6098  inline void
6100  {
6101  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6102  }
6103 
6105  inline int
6107  {
6108  return (int) (m_listCustom.size());
6109  }
6110 
6111  EResultCode
6113  addCustom (
6114  CParameter * pValue);
6115 
6116 
6117 };
6118 
6119 
6143 class CImpinjEnableRFPhaseAngle : public CParameter
6144 {
6145  public:
6147  ~CImpinjEnableRFPhaseAngle (void);
6148 
6151 
6152  static const CFieldDescriptor * const
6153  s_apFieldDescriptorTable[];
6154 
6155  static const CTypeDescriptor
6156  s_typeDescriptor;
6157 
6158  void
6159  decodeFields (
6160  CDecoderStream * pDecoderStream);
6161 
6162  void
6163  assimilateSubParameters (
6164  CErrorDetails * pError);
6165 
6166  void
6167  encode (
6168  CEncoderStream * pEncoderStream) const;
6169 
6170 
6171  llrp_bool_t
6172  isAllowedIn (
6173  const CTypeDescriptor * pEnclosingElementType) const;
6174 
6175 
6176  static CElement *
6177  s_construct (void);
6178 
6179  static void
6180  s_decodeFields (
6181  CDecoderStream * pDecoderStream,
6182  CElement * pElement);
6184 
6185 
6186  protected:
6187  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
6188 
6191  public:
6192  static const CFieldDescriptor
6193  s_fdRFPhaseAngleMode;
6195 
6197  inline EImpinjRFPhaseAngleMode
6199  {
6200  return m_eRFPhaseAngleMode;
6201  }
6202 
6204  inline void
6206  EImpinjRFPhaseAngleMode value)
6207  {
6208  m_eRFPhaseAngleMode = value;
6209  }
6210 
6211 
6212 
6213  protected:
6214  std::list<CParameter *> m_listCustom;
6215 
6216  public:
6218  inline std::list<CParameter *>::iterator
6220  {
6221  return m_listCustom.begin();
6222  }
6223 
6225  inline std::list<CParameter *>::iterator
6226  endCustom (void)
6227  {
6228  return m_listCustom.end();
6229  }
6230 
6232  inline void
6234  {
6235  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6236  }
6237 
6239  inline int
6241  {
6242  return (int) (m_listCustom.size());
6243  }
6244 
6245  EResultCode
6247  addCustom (
6248  CParameter * pValue);
6249 
6250 
6251 };
6252 
6253 
6277 class CImpinjEnablePeakRSSI : public CParameter
6278 {
6279  public:
6280  CImpinjEnablePeakRSSI (void);
6281  ~CImpinjEnablePeakRSSI (void);
6282 
6285 
6286  static const CFieldDescriptor * const
6287  s_apFieldDescriptorTable[];
6288 
6289  static const CTypeDescriptor
6290  s_typeDescriptor;
6291 
6292  void
6293  decodeFields (
6294  CDecoderStream * pDecoderStream);
6295 
6296  void
6297  assimilateSubParameters (
6298  CErrorDetails * pError);
6299 
6300  void
6301  encode (
6302  CEncoderStream * pEncoderStream) const;
6303 
6304 
6305  llrp_bool_t
6306  isAllowedIn (
6307  const CTypeDescriptor * pEnclosingElementType) const;
6308 
6309 
6310  static CElement *
6311  s_construct (void);
6312 
6313  static void
6314  s_decodeFields (
6315  CDecoderStream * pDecoderStream,
6316  CElement * pElement);
6318 
6319 
6320  protected:
6321  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6322 
6325  public:
6326  static const CFieldDescriptor
6327  s_fdPeakRSSIMode;
6329 
6331  inline EImpinjPeakRSSIMode
6333  {
6334  return m_ePeakRSSIMode;
6335  }
6336 
6338  inline void
6340  EImpinjPeakRSSIMode value)
6341  {
6342  m_ePeakRSSIMode = value;
6343  }
6344 
6345 
6346 
6347  protected:
6348  std::list<CParameter *> m_listCustom;
6349 
6350  public:
6352  inline std::list<CParameter *>::iterator
6354  {
6355  return m_listCustom.begin();
6356  }
6357 
6359  inline std::list<CParameter *>::iterator
6360  endCustom (void)
6361  {
6362  return m_listCustom.end();
6363  }
6364 
6366  inline void
6368  {
6369  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6370  }
6371 
6373  inline int
6375  {
6376  return (int) (m_listCustom.size());
6377  }
6378 
6379  EResultCode
6381  addCustom (
6382  CParameter * pValue);
6383 
6384 
6385 };
6386 
6387 
6411 class CImpinjEnableGPSCoordinates : public CParameter
6412 {
6413  public:
6416 
6419 
6420  static const CFieldDescriptor * const
6421  s_apFieldDescriptorTable[];
6422 
6423  static const CTypeDescriptor
6424  s_typeDescriptor;
6425 
6426  void
6427  decodeFields (
6428  CDecoderStream * pDecoderStream);
6429 
6430  void
6431  assimilateSubParameters (
6432  CErrorDetails * pError);
6433 
6434  void
6435  encode (
6436  CEncoderStream * pEncoderStream) const;
6437 
6438 
6439  llrp_bool_t
6440  isAllowedIn (
6441  const CTypeDescriptor * pEnclosingElementType) const;
6442 
6443 
6444  static CElement *
6445  s_construct (void);
6446 
6447  static void
6448  s_decodeFields (
6449  CDecoderStream * pDecoderStream,
6450  CElement * pElement);
6452 
6453 
6454  protected:
6455  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6456 
6459  public:
6460  static const CFieldDescriptor
6461  s_fdGPSCoordinatesMode;
6463 
6465  inline EImpinjGPSCoordinatesMode
6467  {
6468  return m_eGPSCoordinatesMode;
6469  }
6470 
6472  inline void
6474  EImpinjGPSCoordinatesMode value)
6475  {
6476  m_eGPSCoordinatesMode = value;
6477  }
6478 
6479 
6480 
6481  protected:
6482  std::list<CParameter *> m_listCustom;
6483 
6484  public:
6486  inline std::list<CParameter *>::iterator
6488  {
6489  return m_listCustom.begin();
6490  }
6491 
6493  inline std::list<CParameter *>::iterator
6494  endCustom (void)
6495  {
6496  return m_listCustom.end();
6497  }
6498 
6500  inline void
6502  {
6503  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6504  }
6505 
6507  inline int
6509  {
6510  return (int) (m_listCustom.size());
6511  }
6512 
6513  EResultCode
6515  addCustom (
6516  CParameter * pValue);
6517 
6518 
6519 };
6520 
6521 
6547 class CImpinjSerializedTID : public CParameter
6548 {
6549  public:
6550  CImpinjSerializedTID (void);
6551  ~CImpinjSerializedTID (void);
6552 
6555 
6556  static const CFieldDescriptor * const
6557  s_apFieldDescriptorTable[];
6558 
6559  static const CTypeDescriptor
6560  s_typeDescriptor;
6561 
6562  void
6563  decodeFields (
6564  CDecoderStream * pDecoderStream);
6565 
6566  void
6567  assimilateSubParameters (
6568  CErrorDetails * pError);
6569 
6570  void
6571  encode (
6572  CEncoderStream * pEncoderStream) const;
6573 
6574 
6575  llrp_bool_t
6576  isAllowedIn (
6577  const CTypeDescriptor * pEnclosingElementType) const;
6578 
6579 
6580  static CElement *
6581  s_construct (void);
6582 
6583  static void
6584  s_decodeFields (
6585  CDecoderStream * pDecoderStream,
6586  CElement * pElement);
6588 
6589 
6590  protected:
6591  llrp_u16v_t m_TID;
6592 
6595  public:
6596  static const CFieldDescriptor
6597  s_fdTID;
6599 
6601  inline llrp_u16v_t
6602  getTID (void)
6603  {
6604  return m_TID;
6605  }
6606 
6608  inline void
6610  llrp_u16v_t value)
6611  {
6612  m_TID = value;
6613  }
6614 
6615 
6616 
6617  protected:
6618  CImpinjTIDParity * m_pImpinjTIDParity;
6619 
6620  public:
6622  inline CImpinjTIDParity *
6624  {
6625  return m_pImpinjTIDParity;
6626  }
6627 
6629  EResultCode
6630  setImpinjTIDParity (
6631  CImpinjTIDParity * pValue);
6632 
6633 
6634  protected:
6635  std::list<CParameter *> m_listCustom;
6636 
6637  public:
6639  inline std::list<CParameter *>::iterator
6641  {
6642  return m_listCustom.begin();
6643  }
6644 
6646  inline std::list<CParameter *>::iterator
6647  endCustom (void)
6648  {
6649  return m_listCustom.end();
6650  }
6651 
6653  inline void
6655  {
6656  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6657  }
6658 
6660  inline int
6662  {
6663  return (int) (m_listCustom.size());
6664  }
6665 
6666  EResultCode
6668  addCustom (
6669  CParameter * pValue);
6670 
6671 
6672 };
6673 
6674 
6699 class CImpinjRFPhaseAngle : public CParameter
6700 {
6701  public:
6702  CImpinjRFPhaseAngle (void);
6703  ~CImpinjRFPhaseAngle (void);
6704 
6707 
6708  static const CFieldDescriptor * const
6709  s_apFieldDescriptorTable[];
6710 
6711  static const CTypeDescriptor
6712  s_typeDescriptor;
6713 
6714  void
6715  decodeFields (
6716  CDecoderStream * pDecoderStream);
6717 
6718  void
6719  assimilateSubParameters (
6720  CErrorDetails * pError);
6721 
6722  void
6723  encode (
6724  CEncoderStream * pEncoderStream) const;
6725 
6726 
6727  llrp_bool_t
6728  isAllowedIn (
6729  const CTypeDescriptor * pEnclosingElementType) const;
6730 
6731 
6732  static CElement *
6733  s_construct (void);
6734 
6735  static void
6736  s_decodeFields (
6737  CDecoderStream * pDecoderStream,
6738  CElement * pElement);
6740 
6741 
6742  protected:
6743  llrp_u16_t m_PhaseAngle;
6744 
6747  public:
6748  static const CFieldDescriptor
6749  s_fdPhaseAngle;
6751 
6753  inline llrp_u16_t
6755  {
6756  return m_PhaseAngle;
6757  }
6758 
6760  inline void
6762  llrp_u16_t value)
6763  {
6764  m_PhaseAngle = value;
6765  }
6766 
6767 
6768 
6769  protected:
6770  std::list<CParameter *> m_listCustom;
6771 
6772  public:
6774  inline std::list<CParameter *>::iterator
6776  {
6777  return m_listCustom.begin();
6778  }
6779 
6781  inline std::list<CParameter *>::iterator
6782  endCustom (void)
6783  {
6784  return m_listCustom.end();
6785  }
6786 
6788  inline void
6790  {
6791  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6792  }
6793 
6795  inline int
6797  {
6798  return (int) (m_listCustom.size());
6799  }
6800 
6801  EResultCode
6803  addCustom (
6804  CParameter * pValue);
6805 
6806 
6807 };
6808 
6809 
6834 class CImpinjPeakRSSI : public CParameter
6835 {
6836  public:
6837  CImpinjPeakRSSI (void);
6838  ~CImpinjPeakRSSI (void);
6839 
6842 
6843  static const CFieldDescriptor * const
6844  s_apFieldDescriptorTable[];
6845 
6846  static const CTypeDescriptor
6847  s_typeDescriptor;
6848 
6849  void
6850  decodeFields (
6851  CDecoderStream * pDecoderStream);
6852 
6853  void
6854  assimilateSubParameters (
6855  CErrorDetails * pError);
6856 
6857  void
6858  encode (
6859  CEncoderStream * pEncoderStream) const;
6860 
6861 
6862  llrp_bool_t
6863  isAllowedIn (
6864  const CTypeDescriptor * pEnclosingElementType) const;
6865 
6866 
6867  static CElement *
6868  s_construct (void);
6869 
6870  static void
6871  s_decodeFields (
6872  CDecoderStream * pDecoderStream,
6873  CElement * pElement);
6875 
6876 
6877  protected:
6878  llrp_s16_t m_RSSI;
6879 
6882  public:
6883  static const CFieldDescriptor
6884  s_fdRSSI;
6886 
6888  inline llrp_s16_t
6889  getRSSI (void)
6890  {
6891  return m_RSSI;
6892  }
6893 
6895  inline void
6897  llrp_s16_t value)
6898  {
6899  m_RSSI = value;
6900  }
6901 
6902 
6903 
6904  protected:
6905  std::list<CParameter *> m_listCustom;
6906 
6907  public:
6909  inline std::list<CParameter *>::iterator
6911  {
6912  return m_listCustom.begin();
6913  }
6914 
6916  inline std::list<CParameter *>::iterator
6917  endCustom (void)
6918  {
6919  return m_listCustom.end();
6920  }
6921 
6923  inline void
6925  {
6926  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6927  }
6928 
6930  inline int
6932  {
6933  return (int) (m_listCustom.size());
6934  }
6935 
6936  EResultCode
6938  addCustom (
6939  CParameter * pValue);
6940 
6941 
6942 };
6943 
6944 
6970 class CImpinjGPSCoordinates : public CParameter
6971 {
6972  public:
6973  CImpinjGPSCoordinates (void);
6974  ~CImpinjGPSCoordinates (void);
6975 
6978 
6979  static const CFieldDescriptor * const
6980  s_apFieldDescriptorTable[];
6981 
6982  static const CTypeDescriptor
6983  s_typeDescriptor;
6984 
6985  void
6986  decodeFields (
6987  CDecoderStream * pDecoderStream);
6988 
6989  void
6990  assimilateSubParameters (
6991  CErrorDetails * pError);
6992 
6993  void
6994  encode (
6995  CEncoderStream * pEncoderStream) const;
6996 
6997 
6998  llrp_bool_t
6999  isAllowedIn (
7000  const CTypeDescriptor * pEnclosingElementType) const;
7001 
7002 
7003  static CElement *
7004  s_construct (void);
7005 
7006  static void
7007  s_decodeFields (
7008  CDecoderStream * pDecoderStream,
7009  CElement * pElement);
7011 
7012 
7013  protected:
7014  llrp_s32_t m_Latitude;
7015 
7018  public:
7019  static const CFieldDescriptor
7020  s_fdLatitude;
7022 
7024  inline llrp_s32_t
7026  {
7027  return m_Latitude;
7028  }
7029 
7031  inline void
7033  llrp_s32_t value)
7034  {
7035  m_Latitude = value;
7036  }
7037 
7038 
7039  protected:
7040  llrp_s32_t m_Longitude;
7041 
7044  public:
7045  static const CFieldDescriptor
7046  s_fdLongitude;
7048 
7050  inline llrp_s32_t
7052  {
7053  return m_Longitude;
7054  }
7055 
7057  inline void
7059  llrp_s32_t value)
7060  {
7061  m_Longitude = value;
7062  }
7063 
7064 
7065 
7066  protected:
7067  std::list<CParameter *> m_listCustom;
7068 
7069  public:
7071  inline std::list<CParameter *>::iterator
7073  {
7074  return m_listCustom.begin();
7075  }
7076 
7078  inline std::list<CParameter *>::iterator
7079  endCustom (void)
7080  {
7081  return m_listCustom.end();
7082  }
7083 
7085  inline void
7087  {
7088  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7089  }
7090 
7092  inline int
7094  {
7095  return (int) (m_listCustom.size());
7096  }
7097 
7098  EResultCode
7100  addCustom (
7101  CParameter * pValue);
7102 
7103 
7104 };
7105 
7106 
7131 class CImpinjLoopSpec : public CParameter
7132 {
7133  public:
7134  CImpinjLoopSpec (void);
7135  ~CImpinjLoopSpec (void);
7136 
7139 
7140  static const CFieldDescriptor * const
7141  s_apFieldDescriptorTable[];
7142 
7143  static const CTypeDescriptor
7144  s_typeDescriptor;
7145 
7146  void
7147  decodeFields (
7148  CDecoderStream * pDecoderStream);
7149 
7150  void
7151  assimilateSubParameters (
7152  CErrorDetails * pError);
7153 
7154  void
7155  encode (
7156  CEncoderStream * pEncoderStream) const;
7157 
7158 
7159  llrp_bool_t
7160  isAllowedIn (
7161  const CTypeDescriptor * pEnclosingElementType) const;
7162 
7163 
7164  static CElement *
7165  s_construct (void);
7166 
7167  static void
7168  s_decodeFields (
7169  CDecoderStream * pDecoderStream,
7170  CElement * pElement);
7172 
7173 
7174  protected:
7175  llrp_u32_t m_LoopCount;
7176 
7179  public:
7180  static const CFieldDescriptor
7181  s_fdLoopCount;
7183 
7185  inline llrp_u32_t
7187  {
7188  return m_LoopCount;
7189  }
7190 
7192  inline void
7194  llrp_u32_t value)
7195  {
7196  m_LoopCount = value;
7197  }
7198 
7199 
7200 
7201  protected:
7202  std::list<CParameter *> m_listCustom;
7203 
7204  public:
7206  inline std::list<CParameter *>::iterator
7208  {
7209  return m_listCustom.begin();
7210  }
7211 
7213  inline std::list<CParameter *>::iterator
7214  endCustom (void)
7215  {
7216  return m_listCustom.end();
7217  }
7218 
7220  inline void
7222  {
7223  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7224  }
7225 
7227  inline int
7229  {
7230  return (int) (m_listCustom.size());
7231  }
7232 
7233  EResultCode
7235  addCustom (
7236  CParameter * pValue);
7237 
7238 
7239 };
7240 
7241 
7267 class CImpinjGPSNMEASentences : public CParameter
7268 {
7269  public:
7270  CImpinjGPSNMEASentences (void);
7271  ~CImpinjGPSNMEASentences (void);
7272 
7275 
7276  static const CFieldDescriptor * const
7277  s_apFieldDescriptorTable[];
7278 
7279  static const CTypeDescriptor
7280  s_typeDescriptor;
7281 
7282  void
7283  decodeFields (
7284  CDecoderStream * pDecoderStream);
7285 
7286  void
7287  assimilateSubParameters (
7288  CErrorDetails * pError);
7289 
7290  void
7291  encode (
7292  CEncoderStream * pEncoderStream) const;
7293 
7294 
7295  llrp_bool_t
7296  isAllowedIn (
7297  const CTypeDescriptor * pEnclosingElementType) const;
7298 
7299 
7300  static CElement *
7301  s_construct (void);
7302 
7303  static void
7304  s_decodeFields (
7305  CDecoderStream * pDecoderStream,
7306  CElement * pElement);
7308 
7309 
7310 
7311  protected:
7312  CImpinjGGASentence * m_pImpinjGGASentence;
7313 
7314  public:
7316  inline CImpinjGGASentence *
7318  {
7319  return m_pImpinjGGASentence;
7320  }
7321 
7323  EResultCode
7324  setImpinjGGASentence (
7325  CImpinjGGASentence * pValue);
7326 
7327 
7328  protected:
7329  CImpinjRMCSentence * m_pImpinjRMCSentence;
7330 
7331  public:
7333  inline CImpinjRMCSentence *
7335  {
7336  return m_pImpinjRMCSentence;
7337  }
7338 
7340  EResultCode
7341  setImpinjRMCSentence (
7342  CImpinjRMCSentence * pValue);
7343 
7344 
7345  protected:
7346  std::list<CParameter *> m_listCustom;
7347 
7348  public:
7350  inline std::list<CParameter *>::iterator
7352  {
7353  return m_listCustom.begin();
7354  }
7355 
7357  inline std::list<CParameter *>::iterator
7358  endCustom (void)
7359  {
7360  return m_listCustom.end();
7361  }
7362 
7364  inline void
7366  {
7367  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7368  }
7369 
7371  inline int
7373  {
7374  return (int) (m_listCustom.size());
7375  }
7376 
7377  EResultCode
7379  addCustom (
7380  CParameter * pValue);
7381 
7382 
7383 };
7384 
7385 
7409 class CImpinjGGASentence : public CParameter
7410 {
7411  public:
7412  CImpinjGGASentence (void);
7413  ~CImpinjGGASentence (void);
7414 
7417 
7418  static const CFieldDescriptor * const
7419  s_apFieldDescriptorTable[];
7420 
7421  static const CTypeDescriptor
7422  s_typeDescriptor;
7423 
7424  void
7425  decodeFields (
7426  CDecoderStream * pDecoderStream);
7427 
7428  void
7429  assimilateSubParameters (
7430  CErrorDetails * pError);
7431 
7432  void
7433  encode (
7434  CEncoderStream * pEncoderStream) const;
7435 
7436 
7437  llrp_bool_t
7438  isAllowedIn (
7439  const CTypeDescriptor * pEnclosingElementType) const;
7440 
7441 
7442  static CElement *
7443  s_construct (void);
7444 
7445  static void
7446  s_decodeFields (
7447  CDecoderStream * pDecoderStream,
7448  CElement * pElement);
7450 
7451 
7452  protected:
7453  llrp_utf8v_t m_GGASentence;
7454 
7457  public:
7458  static const CFieldDescriptor
7459  s_fdGGASentence;
7461 
7463  inline llrp_utf8v_t
7465  {
7466  return m_GGASentence;
7467  }
7468 
7470  inline void
7472  llrp_utf8v_t value)
7473  {
7474  m_GGASentence = value;
7475  }
7476 
7477 
7478 
7479  protected:
7480  std::list<CParameter *> m_listCustom;
7481 
7482  public:
7484  inline std::list<CParameter *>::iterator
7486  {
7487  return m_listCustom.begin();
7488  }
7489 
7491  inline std::list<CParameter *>::iterator
7492  endCustom (void)
7493  {
7494  return m_listCustom.end();
7495  }
7496 
7498  inline void
7500  {
7501  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7502  }
7503 
7505  inline int
7507  {
7508  return (int) (m_listCustom.size());
7509  }
7510 
7511  EResultCode
7513  addCustom (
7514  CParameter * pValue);
7515 
7516 
7517 };
7518 
7519 
7543 class CImpinjRMCSentence : public CParameter
7544 {
7545  public:
7546  CImpinjRMCSentence (void);
7547  ~CImpinjRMCSentence (void);
7548 
7551 
7552  static const CFieldDescriptor * const
7553  s_apFieldDescriptorTable[];
7554 
7555  static const CTypeDescriptor
7556  s_typeDescriptor;
7557 
7558  void
7559  decodeFields (
7560  CDecoderStream * pDecoderStream);
7561 
7562  void
7563  assimilateSubParameters (
7564  CErrorDetails * pError);
7565 
7566  void
7567  encode (
7568  CEncoderStream * pEncoderStream) const;
7569 
7570 
7571  llrp_bool_t
7572  isAllowedIn (
7573  const CTypeDescriptor * pEnclosingElementType) const;
7574 
7575 
7576  static CElement *
7577  s_construct (void);
7578 
7579  static void
7580  s_decodeFields (
7581  CDecoderStream * pDecoderStream,
7582  CElement * pElement);
7584 
7585 
7586  protected:
7587  llrp_utf8v_t m_RMCSentence;
7588 
7591  public:
7592  static const CFieldDescriptor
7593  s_fdRMCSentence;
7595 
7597  inline llrp_utf8v_t
7599  {
7600  return m_RMCSentence;
7601  }
7602 
7604  inline void
7606  llrp_utf8v_t value)
7607  {
7608  m_RMCSentence = value;
7609  }
7610 
7611 
7612 
7613  protected:
7614  std::list<CParameter *> m_listCustom;
7615 
7616  public:
7618  inline std::list<CParameter *>::iterator
7620  {
7621  return m_listCustom.begin();
7622  }
7623 
7625  inline std::list<CParameter *>::iterator
7626  endCustom (void)
7627  {
7628  return m_listCustom.end();
7629  }
7630 
7632  inline void
7634  {
7635  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7636  }
7637 
7639  inline int
7641  {
7642  return (int) (m_listCustom.size());
7643  }
7644 
7645  EResultCode
7647  addCustom (
7648  CParameter * pValue);
7649 
7650 
7651 };
7652 
7653 
7677 class CImpinjOpSpecRetryCount : public CParameter
7678 {
7679  public:
7680  CImpinjOpSpecRetryCount (void);
7681  ~CImpinjOpSpecRetryCount (void);
7682 
7685 
7686  static const CFieldDescriptor * const
7687  s_apFieldDescriptorTable[];
7688 
7689  static const CTypeDescriptor
7690  s_typeDescriptor;
7691 
7692  void
7693  decodeFields (
7694  CDecoderStream * pDecoderStream);
7695 
7696  void
7697  assimilateSubParameters (
7698  CErrorDetails * pError);
7699 
7700  void
7701  encode (
7702  CEncoderStream * pEncoderStream) const;
7703 
7704 
7705  llrp_bool_t
7706  isAllowedIn (
7707  const CTypeDescriptor * pEnclosingElementType) const;
7708 
7709 
7710  static CElement *
7711  s_construct (void);
7712 
7713  static void
7714  s_decodeFields (
7715  CDecoderStream * pDecoderStream,
7716  CElement * pElement);
7718 
7719 
7720  protected:
7721  llrp_u16_t m_RetryCount;
7722 
7725  public:
7726  static const CFieldDescriptor
7727  s_fdRetryCount;
7729 
7731  inline llrp_u16_t
7733  {
7734  return m_RetryCount;
7735  }
7736 
7738  inline void
7740  llrp_u16_t value)
7741  {
7742  m_RetryCount = value;
7743  }
7744 
7745 
7746 
7747  protected:
7748  std::list<CParameter *> m_listCustom;
7749 
7750  public:
7752  inline std::list<CParameter *>::iterator
7754  {
7755  return m_listCustom.begin();
7756  }
7757 
7759  inline std::list<CParameter *>::iterator
7760  endCustom (void)
7761  {
7762  return m_listCustom.end();
7763  }
7764 
7766  inline void
7768  {
7769  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7770  }
7771 
7773  inline int
7775  {
7776  return (int) (m_listCustom.size());
7777  }
7778 
7779  EResultCode
7781  addCustom (
7782  CParameter * pValue);
7783 
7784 
7785 };
7786 
7787 
7815 class CImpinjAdvancedGPOConfiguration : public CParameter
7816 {
7817  public:
7820 
7823 
7824  static const CFieldDescriptor * const
7825  s_apFieldDescriptorTable[];
7826 
7827  static const CTypeDescriptor
7828  s_typeDescriptor;
7829 
7830  void
7831  decodeFields (
7832  CDecoderStream * pDecoderStream);
7833 
7834  void
7835  assimilateSubParameters (
7836  CErrorDetails * pError);
7837 
7838  void
7839  encode (
7840  CEncoderStream * pEncoderStream) const;
7841 
7842 
7843  llrp_bool_t
7844  isAllowedIn (
7845  const CTypeDescriptor * pEnclosingElementType) const;
7846 
7847 
7848  static CElement *
7849  s_construct (void);
7850 
7851  static void
7852  s_decodeFields (
7853  CDecoderStream * pDecoderStream,
7854  CElement * pElement);
7856 
7857 
7858  protected:
7859  llrp_u16_t m_GPOPortNum;
7860 
7863  public:
7864  static const CFieldDescriptor
7865  s_fdGPOPortNum;
7867 
7869  inline llrp_u16_t
7871  {
7872  return m_GPOPortNum;
7873  }
7874 
7876  inline void
7878  llrp_u16_t value)
7879  {
7880  m_GPOPortNum = value;
7881  }
7882 
7883 
7884  protected:
7885  EImpinjAdvancedGPOMode m_eGPOMode;
7886 
7889  public:
7890  static const CFieldDescriptor
7891  s_fdGPOMode;
7893 
7895  inline EImpinjAdvancedGPOMode
7896  getGPOMode (void)
7897  {
7898  return m_eGPOMode;
7899  }
7900 
7902  inline void
7904  EImpinjAdvancedGPOMode value)
7905  {
7906  m_eGPOMode = value;
7907  }
7908 
7909 
7910  protected:
7911  llrp_u32_t m_GPOPulseDurationMSec;
7912 
7915  public:
7916  static const CFieldDescriptor
7917  s_fdGPOPulseDurationMSec;
7919 
7921  inline llrp_u32_t
7923  {
7924  return m_GPOPulseDurationMSec;
7925  }
7926 
7928  inline void
7930  llrp_u32_t value)
7931  {
7932  m_GPOPulseDurationMSec = value;
7933  }
7934 
7935 
7936 
7937  protected:
7938  std::list<CParameter *> m_listCustom;
7939 
7940  public:
7942  inline std::list<CParameter *>::iterator
7944  {
7945  return m_listCustom.begin();
7946  }
7947 
7949  inline std::list<CParameter *>::iterator
7950  endCustom (void)
7951  {
7952  return m_listCustom.end();
7953  }
7954 
7956  inline void
7958  {
7959  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7960  }
7961 
7963  inline int
7965  {
7966  return (int) (m_listCustom.size());
7967  }
7968 
7969  EResultCode
7971  addCustom (
7972  CParameter * pValue);
7973 
7974 
7975 };
7976 
7977 
8011 class CImpinjEnableOptimizedRead : public CParameter
8012 {
8013  public:
8016 
8019 
8020  static const CFieldDescriptor * const
8021  s_apFieldDescriptorTable[];
8022 
8023  static const CTypeDescriptor
8024  s_typeDescriptor;
8025 
8026  void
8027  decodeFields (
8028  CDecoderStream * pDecoderStream);
8029 
8030  void
8031  assimilateSubParameters (
8032  CErrorDetails * pError);
8033 
8034  void
8035  encode (
8036  CEncoderStream * pEncoderStream) const;
8037 
8038 
8039  llrp_bool_t
8040  isAllowedIn (
8041  const CTypeDescriptor * pEnclosingElementType) const;
8042 
8043 
8044  static CElement *
8045  s_construct (void);
8046 
8047  static void
8048  s_decodeFields (
8049  CDecoderStream * pDecoderStream,
8050  CElement * pElement);
8052 
8053 
8054  protected:
8055  EImpinjOptimizedReadMode m_eOptimizedReadMode;
8056 
8059  public:
8060  static const CFieldDescriptor
8061  s_fdOptimizedReadMode;
8063 
8065  inline EImpinjOptimizedReadMode
8067  {
8068  return m_eOptimizedReadMode;
8069  }
8070 
8072  inline void
8074  EImpinjOptimizedReadMode value)
8075  {
8076  m_eOptimizedReadMode = value;
8077  }
8078 
8079 
8080 
8081  protected:
8082  std::list<CC1G2Read *> m_listC1G2Read;
8083 
8084  public:
8086  inline std::list<CC1G2Read *>::iterator
8088  {
8089  return m_listC1G2Read.begin();
8090  }
8091 
8093  inline std::list<CC1G2Read *>::iterator
8095  {
8096  return m_listC1G2Read.end();
8097  }
8098 
8100  inline void
8102  {
8103  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
8104  }
8105 
8107  inline int
8109  {
8110  return (int) (m_listC1G2Read.size());
8111  }
8112 
8113  EResultCode
8115  addC1G2Read (
8116  CC1G2Read * pValue);
8117 
8118 
8119  protected:
8120  std::list<CParameter *> m_listCustom;
8121 
8122  public:
8124  inline std::list<CParameter *>::iterator
8126  {
8127  return m_listCustom.begin();
8128  }
8129 
8131  inline std::list<CParameter *>::iterator
8132  endCustom (void)
8133  {
8134  return m_listCustom.end();
8135  }
8136 
8138  inline void
8140  {
8141  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8142  }
8143 
8145  inline int
8147  {
8148  return (int) (m_listCustom.size());
8149  }
8150 
8151  EResultCode
8153  addCustom (
8154  CParameter * pValue);
8155 
8156 
8157 };
8158 
8159 
8186 class CImpinjAccessSpecOrdering : public CParameter
8187 {
8188  public:
8190  ~CImpinjAccessSpecOrdering (void);
8191 
8194 
8195  static const CFieldDescriptor * const
8196  s_apFieldDescriptorTable[];
8197 
8198  static const CTypeDescriptor
8199  s_typeDescriptor;
8200 
8201  void
8202  decodeFields (
8203  CDecoderStream * pDecoderStream);
8204 
8205  void
8206  assimilateSubParameters (
8207  CErrorDetails * pError);
8208 
8209  void
8210  encode (
8211  CEncoderStream * pEncoderStream) const;
8212 
8213 
8214  llrp_bool_t
8215  isAllowedIn (
8216  const CTypeDescriptor * pEnclosingElementType) const;
8217 
8218 
8219  static CElement *
8220  s_construct (void);
8221 
8222  static void
8223  s_decodeFields (
8224  CDecoderStream * pDecoderStream,
8225  CElement * pElement);
8227 
8228 
8229  protected:
8230  EImpinjAccessSpecOrderingMode m_eOrderingMode;
8231 
8234  public:
8235  static const CFieldDescriptor
8236  s_fdOrderingMode;
8238 
8240  inline EImpinjAccessSpecOrderingMode
8242  {
8243  return m_eOrderingMode;
8244  }
8245 
8247  inline void
8249  EImpinjAccessSpecOrderingMode value)
8250  {
8251  m_eOrderingMode = value;
8252  }
8253 
8254 
8255 
8256  protected:
8257  std::list<CParameter *> m_listCustom;
8258 
8259  public:
8261  inline std::list<CParameter *>::iterator
8263  {
8264  return m_listCustom.begin();
8265  }
8266 
8268  inline std::list<CParameter *>::iterator
8269  endCustom (void)
8270  {
8271  return m_listCustom.end();
8272  }
8273 
8275  inline void
8277  {
8278  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8279  }
8280 
8282  inline int
8284  {
8285  return (int) (m_listCustom.size());
8286  }
8287 
8288  EResultCode
8290  addCustom (
8291  CParameter * pValue);
8292 
8293 
8294 };
8295 
8296 
8320 class CImpinjEnableRFDopplerFrequency : public CParameter
8321 {
8322  public:
8325 
8328 
8329  static const CFieldDescriptor * const
8330  s_apFieldDescriptorTable[];
8331 
8332  static const CTypeDescriptor
8333  s_typeDescriptor;
8334 
8335  void
8336  decodeFields (
8337  CDecoderStream * pDecoderStream);
8338 
8339  void
8340  assimilateSubParameters (
8341  CErrorDetails * pError);
8342 
8343  void
8344  encode (
8345  CEncoderStream * pEncoderStream) const;
8346 
8347 
8348  llrp_bool_t
8349  isAllowedIn (
8350  const CTypeDescriptor * pEnclosingElementType) const;
8351 
8352 
8353  static CElement *
8354  s_construct (void);
8355 
8356  static void
8357  s_decodeFields (
8358  CDecoderStream * pDecoderStream,
8359  CElement * pElement);
8361 
8362 
8363  protected:
8364  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8365 
8368  public:
8369  static const CFieldDescriptor
8370  s_fdRFDopplerFrequencyMode;
8372 
8374  inline EImpinjRFDopplerFrequencyMode
8376  {
8377  return m_eRFDopplerFrequencyMode;
8378  }
8379 
8381  inline void
8383  EImpinjRFDopplerFrequencyMode value)
8384  {
8385  m_eRFDopplerFrequencyMode = value;
8386  }
8387 
8388 
8389 
8390  protected:
8391  std::list<CParameter *> m_listCustom;
8392 
8393  public:
8395  inline std::list<CParameter *>::iterator
8397  {
8398  return m_listCustom.begin();
8399  }
8400 
8402  inline std::list<CParameter *>::iterator
8403  endCustom (void)
8404  {
8405  return m_listCustom.end();
8406  }
8407 
8409  inline void
8411  {
8412  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8413  }
8414 
8416  inline int
8418  {
8419  return (int) (m_listCustom.size());
8420  }
8421 
8422  EResultCode
8424  addCustom (
8425  CParameter * pValue);
8426 
8427 
8428 };
8429 
8430 
8455 class CImpinjRFDopplerFrequency : public CParameter
8456 {
8457  public:
8459  ~CImpinjRFDopplerFrequency (void);
8460 
8463 
8464  static const CFieldDescriptor * const
8465  s_apFieldDescriptorTable[];
8466 
8467  static const CTypeDescriptor
8468  s_typeDescriptor;
8469 
8470  void
8471  decodeFields (
8472  CDecoderStream * pDecoderStream);
8473 
8474  void
8475  assimilateSubParameters (
8476  CErrorDetails * pError);
8477 
8478  void
8479  encode (
8480  CEncoderStream * pEncoderStream) const;
8481 
8482 
8483  llrp_bool_t
8484  isAllowedIn (
8485  const CTypeDescriptor * pEnclosingElementType) const;
8486 
8487 
8488  static CElement *
8489  s_construct (void);
8490 
8491  static void
8492  s_decodeFields (
8493  CDecoderStream * pDecoderStream,
8494  CElement * pElement);
8496 
8497 
8498  protected:
8499  llrp_s16_t m_DopplerFrequency;
8500 
8503  public:
8504  static const CFieldDescriptor
8505  s_fdDopplerFrequency;
8507 
8509  inline llrp_s16_t
8511  {
8512  return m_DopplerFrequency;
8513  }
8514 
8516  inline void
8518  llrp_s16_t value)
8519  {
8520  m_DopplerFrequency = value;
8521  }
8522 
8523 
8524 
8525  protected:
8526  std::list<CParameter *> m_listCustom;
8527 
8528  public:
8530  inline std::list<CParameter *>::iterator
8532  {
8533  return m_listCustom.begin();
8534  }
8535 
8537  inline std::list<CParameter *>::iterator
8538  endCustom (void)
8539  {
8540  return m_listCustom.end();
8541  }
8542 
8544  inline void
8546  {
8547  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8548  }
8549 
8551  inline int
8553  {
8554  return (int) (m_listCustom.size());
8555  }
8556 
8557  EResultCode
8559  addCustom (
8560  CParameter * pValue);
8561 
8562 
8563 };
8564 
8565 
8598 class CImpinjInventoryConfiguration : public CParameter
8599 {
8600  public:
8603 
8606 
8607  static const CFieldDescriptor * const
8608  s_apFieldDescriptorTable[];
8609 
8610  static const CTypeDescriptor
8611  s_typeDescriptor;
8612 
8613  void
8614  decodeFields (
8615  CDecoderStream * pDecoderStream);
8616 
8617  void
8618  assimilateSubParameters (
8619  CErrorDetails * pError);
8620 
8621  void
8622  encode (
8623  CEncoderStream * pEncoderStream) const;
8624 
8625 
8626  llrp_bool_t
8627  isAllowedIn (
8628  const CTypeDescriptor * pEnclosingElementType) const;
8629 
8630 
8631  static CElement *
8632  s_construct (void);
8633 
8634  static void
8635  s_decodeFields (
8636  CDecoderStream * pDecoderStream,
8637  CElement * pElement);
8639 
8640 
8641  protected:
8642  llrp_u1_t m_EnableAntDwellTimeLimit;
8643 
8646  public:
8647  static const CFieldDescriptor
8648  s_fdEnableAntDwellTimeLimit;
8650 
8652  inline llrp_u1_t
8654  {
8655  return m_EnableAntDwellTimeLimit;
8656  }
8657 
8659  inline void
8661  llrp_u1_t value)
8662  {
8663  m_EnableAntDwellTimeLimit = value;
8664  }
8665 
8666 
8667  protected:
8668  llrp_u1_t m_EnableSelectGapClose;
8669 
8672  public:
8673  static const CFieldDescriptor
8674  s_fdEnableSelectGapClose;
8676 
8678  inline llrp_u1_t
8680  {
8681  return m_EnableSelectGapClose;
8682  }
8683 
8685  inline void
8687  llrp_u1_t value)
8688  {
8689  m_EnableSelectGapClose = value;
8690  }
8691 
8692 
8693 
8694  protected:
8695  std::list<CParameter *> m_listCustom;
8696 
8697  public:
8699  inline std::list<CParameter *>::iterator
8701  {
8702  return m_listCustom.begin();
8703  }
8704 
8706  inline std::list<CParameter *>::iterator
8707  endCustom (void)
8708  {
8709  return m_listCustom.end();
8710  }
8711 
8713  inline void
8715  {
8716  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8717  }
8718 
8720  inline int
8722  {
8723  return (int) (m_listCustom.size());
8724  }
8725 
8726  EResultCode
8728  addCustom (
8729  CParameter * pValue);
8730 
8731 
8732 };
8733 
8734 
8758 class CImpinjEnableTxPower : public CParameter
8759 {
8760  public:
8761  CImpinjEnableTxPower (void);
8762  ~CImpinjEnableTxPower (void);
8763 
8766 
8767  static const CFieldDescriptor * const
8768  s_apFieldDescriptorTable[];
8769 
8770  static const CTypeDescriptor
8771  s_typeDescriptor;
8772 
8773  void
8774  decodeFields (
8775  CDecoderStream * pDecoderStream);
8776 
8777  void
8778  assimilateSubParameters (
8779  CErrorDetails * pError);
8780 
8781  void
8782  encode (
8783  CEncoderStream * pEncoderStream) const;
8784 
8785 
8786  llrp_bool_t
8787  isAllowedIn (
8788  const CTypeDescriptor * pEnclosingElementType) const;
8789 
8790 
8791  static CElement *
8792  s_construct (void);
8793 
8794  static void
8795  s_decodeFields (
8796  CDecoderStream * pDecoderStream,
8797  CElement * pElement);
8799 
8800 
8801  protected:
8802  EImpinjTxPowerReportingModeEnum m_eTxPowerReportingMode;
8803 
8806  public:
8807  static const CFieldDescriptor
8808  s_fdTxPowerReportingMode;
8810 
8812  inline EImpinjTxPowerReportingModeEnum
8814  {
8815  return m_eTxPowerReportingMode;
8816  }
8817 
8819  inline void
8821  EImpinjTxPowerReportingModeEnum value)
8822  {
8823  m_eTxPowerReportingMode = value;
8824  }
8825 
8826 
8827 
8828  protected:
8829  std::list<CParameter *> m_listCustom;
8830 
8831  public:
8833  inline std::list<CParameter *>::iterator
8835  {
8836  return m_listCustom.begin();
8837  }
8838 
8840  inline std::list<CParameter *>::iterator
8841  endCustom (void)
8842  {
8843  return m_listCustom.end();
8844  }
8845 
8847  inline void
8849  {
8850  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8851  }
8852 
8854  inline int
8856  {
8857  return (int) (m_listCustom.size());
8858  }
8859 
8860  EResultCode
8862  addCustom (
8863  CParameter * pValue);
8864 
8865 
8866 };
8867 
8868 
8893 class CImpinjTxPower : public CParameter
8894 {
8895  public:
8896  CImpinjTxPower (void);
8897  ~CImpinjTxPower (void);
8898 
8901 
8902  static const CFieldDescriptor * const
8903  s_apFieldDescriptorTable[];
8904 
8905  static const CTypeDescriptor
8906  s_typeDescriptor;
8907 
8908  void
8909  decodeFields (
8910  CDecoderStream * pDecoderStream);
8911 
8912  void
8913  assimilateSubParameters (
8914  CErrorDetails * pError);
8915 
8916  void
8917  encode (
8918  CEncoderStream * pEncoderStream) const;
8919 
8920 
8921  llrp_bool_t
8922  isAllowedIn (
8923  const CTypeDescriptor * pEnclosingElementType) const;
8924 
8925 
8926  static CElement *
8927  s_construct (void);
8928 
8929  static void
8930  s_decodeFields (
8931  CDecoderStream * pDecoderStream,
8932  CElement * pElement);
8934 
8935 
8936  protected:
8937  llrp_u16_t m_TxPower;
8938 
8941  public:
8942  static const CFieldDescriptor
8943  s_fdTxPower;
8945 
8947  inline llrp_u16_t
8948  getTxPower (void)
8949  {
8950  return m_TxPower;
8951  }
8952 
8954  inline void
8956  llrp_u16_t value)
8957  {
8958  m_TxPower = value;
8959  }
8960 
8961 
8962 
8963  protected:
8964  std::list<CParameter *> m_listCustom;
8965 
8966  public:
8968  inline std::list<CParameter *>::iterator
8970  {
8971  return m_listCustom.begin();
8972  }
8973 
8975  inline std::list<CParameter *>::iterator
8976  endCustom (void)
8977  {
8978  return m_listCustom.end();
8979  }
8980 
8982  inline void
8984  {
8985  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8986  }
8987 
8989  inline int
8991  {
8992  return (int) (m_listCustom.size());
8993  }
8994 
8995  EResultCode
8997  addCustom (
8998  CParameter * pValue);
8999 
9000 
9001 };
9002 
9003 
9030 class CImpinjArrayVersion : public CParameter
9031 {
9032  public:
9033  CImpinjArrayVersion (void);
9034  ~CImpinjArrayVersion (void);
9035 
9038 
9039  static const CFieldDescriptor * const
9040  s_apFieldDescriptorTable[];
9041 
9042  static const CTypeDescriptor
9043  s_typeDescriptor;
9044 
9045  void
9046  decodeFields (
9047  CDecoderStream * pDecoderStream);
9048 
9049  void
9050  assimilateSubParameters (
9051  CErrorDetails * pError);
9052 
9053  void
9054  encode (
9055  CEncoderStream * pEncoderStream) const;
9056 
9057 
9058  llrp_bool_t
9059  isAllowedIn (
9060  const CTypeDescriptor * pEnclosingElementType) const;
9061 
9062 
9063  static CElement *
9064  s_construct (void);
9065 
9066  static void
9067  s_decodeFields (
9068  CDecoderStream * pDecoderStream,
9069  CElement * pElement);
9071 
9072 
9073  protected:
9074  llrp_utf8v_t m_SerialNumber;
9075 
9078  public:
9079  static const CFieldDescriptor
9080  s_fdSerialNumber;
9082 
9084  inline llrp_utf8v_t
9086  {
9087  return m_SerialNumber;
9088  }
9089 
9091  inline void
9093  llrp_utf8v_t value)
9094  {
9095  m_SerialNumber = value;
9096  }
9097 
9098 
9099  protected:
9100  llrp_utf8v_t m_FirmwareVersion;
9101 
9104  public:
9105  static const CFieldDescriptor
9106  s_fdFirmwareVersion;
9108 
9110  inline llrp_utf8v_t
9112  {
9113  return m_FirmwareVersion;
9114  }
9115 
9117  inline void
9119  llrp_utf8v_t value)
9120  {
9121  m_FirmwareVersion = value;
9122  }
9123 
9124 
9125  protected:
9126  llrp_utf8v_t m_PCBAVersion;
9127 
9130  public:
9131  static const CFieldDescriptor
9132  s_fdPCBAVersion;
9134 
9136  inline llrp_utf8v_t
9138  {
9139  return m_PCBAVersion;
9140  }
9141 
9143  inline void
9145  llrp_utf8v_t value)
9146  {
9147  m_PCBAVersion = value;
9148  }
9149 
9150 
9151 
9152  protected:
9153  std::list<CParameter *> m_listCustom;
9154 
9155  public:
9157  inline std::list<CParameter *>::iterator
9159  {
9160  return m_listCustom.begin();
9161  }
9162 
9164  inline std::list<CParameter *>::iterator
9165  endCustom (void)
9166  {
9167  return m_listCustom.end();
9168  }
9169 
9171  inline void
9173  {
9174  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9175  }
9176 
9178  inline int
9180  {
9181  return (int) (m_listCustom.size());
9182  }
9183 
9184  EResultCode
9186  addCustom (
9187  CParameter * pValue);
9188 
9189 
9190 };
9191 
9192 
9225 class CImpinjxArrayCapabilities : public CParameter
9226 {
9227  public:
9229  ~CImpinjxArrayCapabilities (void);
9230 
9233 
9234  static const CFieldDescriptor * const
9235  s_apFieldDescriptorTable[];
9236 
9237  static const CTypeDescriptor
9238  s_typeDescriptor;
9239 
9240  void
9241  decodeFields (
9242  CDecoderStream * pDecoderStream);
9243 
9244  void
9245  assimilateSubParameters (
9246  CErrorDetails * pError);
9247 
9248  void
9249  encode (
9250  CEncoderStream * pEncoderStream) const;
9251 
9252 
9253  llrp_bool_t
9254  isAllowedIn (
9255  const CTypeDescriptor * pEnclosingElementType) const;
9256 
9257 
9258  static CElement *
9259  s_construct (void);
9260 
9261  static void
9262  s_decodeFields (
9263  CDecoderStream * pDecoderStream,
9264  CElement * pElement);
9266 
9267 
9268  protected:
9269  llrp_u32_t m_MaxNumSectors;
9270 
9273  public:
9274  static const CFieldDescriptor
9275  s_fdMaxNumSectors;
9277 
9279  inline llrp_u32_t
9281  {
9282  return m_MaxNumSectors;
9283  }
9284 
9286  inline void
9288  llrp_u32_t value)
9289  {
9290  m_MaxNumSectors = value;
9291  }
9292 
9293 
9294  protected:
9295  llrp_u1_t m_SupportsLISpecs;
9296 
9299  public:
9300  static const CFieldDescriptor
9301  s_fdSupportsLISpecs;
9303 
9305  inline llrp_u1_t
9307  {
9308  return m_SupportsLISpecs;
9309  }
9310 
9312  inline void
9314  llrp_u1_t value)
9315  {
9316  m_SupportsLISpecs = value;
9317  }
9318 
9319 
9320  protected:
9321  llrp_u1_t m_SupportsTISpecs;
9322 
9325  public:
9326  static const CFieldDescriptor
9327  s_fdSupportsTISpecs;
9329 
9331  inline llrp_u1_t
9333  {
9334  return m_SupportsTISpecs;
9335  }
9336 
9338  inline void
9340  llrp_u1_t value)
9341  {
9342  m_SupportsTISpecs = value;
9343  }
9344 
9345 
9346  protected:
9347  llrp_u1_t m_SupportsTSISpecs;
9348 
9351  public:
9352  static const CFieldDescriptor
9353  s_fdSupportsTSISpecs;
9355 
9357  inline llrp_u1_t
9359  {
9360  return m_SupportsTSISpecs;
9361  }
9362 
9364  inline void
9366  llrp_u1_t value)
9367  {
9368  m_SupportsTSISpecs = value;
9369  }
9370 
9371 
9372  protected:
9373  llrp_u1_t m_SupportsDISpecs;
9374 
9377  public:
9378  static const CFieldDescriptor
9379  s_fdSupportsDISpecs;
9381 
9383  inline llrp_u1_t
9385  {
9386  return m_SupportsDISpecs;
9387  }
9388 
9390  inline void
9392  llrp_u1_t value)
9393  {
9394  m_SupportsDISpecs = value;
9395  }
9396 
9397 
9398 
9399  protected:
9400  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
9401 
9402  public:
9406  {
9407  return m_pImpinjxArrayDirectionCapabilities;
9408  }
9409 
9411  EResultCode
9412  setImpinjxArrayDirectionCapabilities (
9414 
9415 
9416  protected:
9417  std::list<CParameter *> m_listCustom;
9418 
9419  public:
9421  inline std::list<CParameter *>::iterator
9423  {
9424  return m_listCustom.begin();
9425  }
9426 
9428  inline std::list<CParameter *>::iterator
9429  endCustom (void)
9430  {
9431  return m_listCustom.end();
9432  }
9433 
9435  inline void
9437  {
9438  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9439  }
9440 
9442  inline int
9444  {
9445  return (int) (m_listCustom.size());
9446  }
9447 
9448  EResultCode
9450  addCustom (
9451  CParameter * pValue);
9452 
9453 
9454 };
9455 
9456 
9484 class CImpinjTiltConfiguration : public CParameter
9485 {
9486  public:
9487  CImpinjTiltConfiguration (void);
9488  ~CImpinjTiltConfiguration (void);
9489 
9492 
9493  static const CFieldDescriptor * const
9494  s_apFieldDescriptorTable[];
9495 
9496  static const CTypeDescriptor
9497  s_typeDescriptor;
9498 
9499  void
9500  decodeFields (
9501  CDecoderStream * pDecoderStream);
9502 
9503  void
9504  assimilateSubParameters (
9505  CErrorDetails * pError);
9506 
9507  void
9508  encode (
9509  CEncoderStream * pEncoderStream) const;
9510 
9511 
9512  llrp_bool_t
9513  isAllowedIn (
9514  const CTypeDescriptor * pEnclosingElementType) const;
9515 
9516 
9517  static CElement *
9518  s_construct (void);
9519 
9520  static void
9521  s_decodeFields (
9522  CDecoderStream * pDecoderStream,
9523  CElement * pElement);
9525 
9526 
9527  protected:
9528  llrp_s32_t m_XAxis;
9529 
9532  public:
9533  static const CFieldDescriptor
9534  s_fdXAxis;
9536 
9538  inline llrp_s32_t
9539  getXAxis (void)
9540  {
9541  return m_XAxis;
9542  }
9543 
9545  inline void
9547  llrp_s32_t value)
9548  {
9549  m_XAxis = value;
9550  }
9551 
9552 
9553  protected:
9554  llrp_s32_t m_YAxis;
9555 
9558  public:
9559  static const CFieldDescriptor
9560  s_fdYAxis;
9562 
9564  inline llrp_s32_t
9565  getYAxis (void)
9566  {
9567  return m_YAxis;
9568  }
9569 
9571  inline void
9573  llrp_s32_t value)
9574  {
9575  m_YAxis = value;
9576  }
9577 
9578 
9579  protected:
9580  llrp_s32_t m_ZAxis;
9581 
9584  public:
9585  static const CFieldDescriptor
9586  s_fdZAxis;
9588 
9590  inline llrp_s32_t
9591  getZAxis (void)
9592  {
9593  return m_ZAxis;
9594  }
9595 
9597  inline void
9599  llrp_s32_t value)
9600  {
9601  m_ZAxis = value;
9602  }
9603 
9604 
9605 
9606  protected:
9607  std::list<CParameter *> m_listCustom;
9608 
9609  public:
9611  inline std::list<CParameter *>::iterator
9613  {
9614  return m_listCustom.begin();
9615  }
9616 
9618  inline std::list<CParameter *>::iterator
9619  endCustom (void)
9620  {
9621  return m_listCustom.end();
9622  }
9623 
9625  inline void
9627  {
9628  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9629  }
9630 
9632  inline int
9634  {
9635  return (int) (m_listCustom.size());
9636  }
9637 
9638  EResultCode
9640  addCustom (
9641  CParameter * pValue);
9642 
9643 
9644 };
9645 
9646 
9675 class CImpinjBeaconConfiguration : public CParameter
9676 {
9677  public:
9680 
9683 
9684  static const CFieldDescriptor * const
9685  s_apFieldDescriptorTable[];
9686 
9687  static const CTypeDescriptor
9688  s_typeDescriptor;
9689 
9690  void
9691  decodeFields (
9692  CDecoderStream * pDecoderStream);
9693 
9694  void
9695  assimilateSubParameters (
9696  CErrorDetails * pError);
9697 
9698  void
9699  encode (
9700  CEncoderStream * pEncoderStream) const;
9701 
9702 
9703  llrp_bool_t
9704  isAllowedIn (
9705  const CTypeDescriptor * pEnclosingElementType) const;
9706 
9707 
9708  static CElement *
9709  s_construct (void);
9710 
9711  static void
9712  s_decodeFields (
9713  CDecoderStream * pDecoderStream,
9714  CElement * pElement);
9716 
9717 
9718  protected:
9719  llrp_u1_t m_BeaconState;
9720 
9723  public:
9724  static const CFieldDescriptor
9725  s_fdBeaconState;
9727 
9729  inline llrp_u1_t
9731  {
9732  return m_BeaconState;
9733  }
9734 
9736  inline void
9738  llrp_u1_t value)
9739  {
9740  m_BeaconState = value;
9741  }
9742 
9743 
9744  protected:
9745  llrp_u64_t m_BeaconDurationSeconds;
9746 
9749  public:
9750  static const CFieldDescriptor
9751  s_fdBeaconDurationSeconds;
9753 
9755  inline llrp_u64_t
9757  {
9758  return m_BeaconDurationSeconds;
9759  }
9760 
9762  inline void
9764  llrp_u64_t value)
9765  {
9766  m_BeaconDurationSeconds = value;
9767  }
9768 
9769 
9770 
9771  protected:
9772  std::list<CParameter *> m_listCustom;
9773 
9774  public:
9776  inline std::list<CParameter *>::iterator
9778  {
9779  return m_listCustom.begin();
9780  }
9781 
9783  inline std::list<CParameter *>::iterator
9784  endCustom (void)
9785  {
9786  return m_listCustom.end();
9787  }
9788 
9790  inline void
9792  {
9793  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9794  }
9795 
9797  inline int
9799  {
9800  return (int) (m_listCustom.size());
9801  }
9802 
9803  EResultCode
9805  addCustom (
9806  CParameter * pValue);
9807 
9808 
9809 };
9810 
9811 
9839 class CImpinjAntennaConfiguration : public CParameter
9840 {
9841  public:
9844 
9847 
9848  static const CFieldDescriptor * const
9849  s_apFieldDescriptorTable[];
9850 
9851  static const CTypeDescriptor
9852  s_typeDescriptor;
9853 
9854  void
9855  decodeFields (
9856  CDecoderStream * pDecoderStream);
9857 
9858  void
9859  assimilateSubParameters (
9860  CErrorDetails * pError);
9861 
9862  void
9863  encode (
9864  CEncoderStream * pEncoderStream) const;
9865 
9866 
9867  llrp_bool_t
9868  isAllowedIn (
9869  const CTypeDescriptor * pEnclosingElementType) const;
9870 
9871 
9872  static CElement *
9873  s_construct (void);
9874 
9875  static void
9876  s_decodeFields (
9877  CDecoderStream * pDecoderStream,
9878  CElement * pElement);
9880 
9881 
9882 
9883  protected:
9884  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9885 
9886  public:
9890  {
9891  return m_pImpinjAntennaEventHysteresis;
9892  }
9893 
9895  EResultCode
9896  setImpinjAntennaEventHysteresis (
9898 
9899 
9900  protected:
9901  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9902 
9903  public:
9907  {
9908  return m_pImpinjAntennaEventConfiguration;
9909  }
9910 
9912  EResultCode
9913  setImpinjAntennaEventConfiguration (
9915 
9916 
9917  protected:
9918  std::list<CParameter *> m_listCustom;
9919 
9920  public:
9922  inline std::list<CParameter *>::iterator
9924  {
9925  return m_listCustom.begin();
9926  }
9927 
9929  inline std::list<CParameter *>::iterator
9930  endCustom (void)
9931  {
9932  return m_listCustom.end();
9933  }
9934 
9936  inline void
9938  {
9939  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9940  }
9941 
9943  inline int
9945  {
9946  return (int) (m_listCustom.size());
9947  }
9948 
9949  EResultCode
9951  addCustom (
9952  CParameter * pValue);
9953 
9954 
9955 };
9956 
9957 
9989 class CImpinjAntennaEventHysteresis : public CParameter
9990 {
9991  public:
9994 
9997 
9998  static const CFieldDescriptor * const
9999  s_apFieldDescriptorTable[];
10000 
10001  static const CTypeDescriptor
10002  s_typeDescriptor;
10003 
10004  void
10005  decodeFields (
10006  CDecoderStream * pDecoderStream);
10007 
10008  void
10009  assimilateSubParameters (
10010  CErrorDetails * pError);
10011 
10012  void
10013  encode (
10014  CEncoderStream * pEncoderStream) const;
10015 
10016 
10017  llrp_bool_t
10018  isAllowedIn (
10019  const CTypeDescriptor * pEnclosingElementType) const;
10020 
10021 
10022  static CElement *
10023  s_construct (void);
10024 
10025  static void
10026  s_decodeFields (
10027  CDecoderStream * pDecoderStream,
10028  CElement * pElement);
10030 
10031 
10032  protected:
10033  llrp_u64_t m_AntennaEventConnected;
10034 
10037  public:
10038  static const CFieldDescriptor
10039  s_fdAntennaEventConnected;
10041 
10043  inline llrp_u64_t
10045  {
10046  return m_AntennaEventConnected;
10047  }
10048 
10050  inline void
10052  llrp_u64_t value)
10053  {
10054  m_AntennaEventConnected = value;
10055  }
10056 
10057 
10058  protected:
10059  llrp_u64_t m_AntennaEventDisconnected;
10060 
10063  public:
10064  static const CFieldDescriptor
10065  s_fdAntennaEventDisconnected;
10067 
10069  inline llrp_u64_t
10071  {
10072  return m_AntennaEventDisconnected;
10073  }
10074 
10076  inline void
10078  llrp_u64_t value)
10079  {
10080  m_AntennaEventDisconnected = value;
10081  }
10082 
10083 
10084 
10085  protected:
10086  std::list<CParameter *> m_listCustom;
10087 
10088  public:
10090  inline std::list<CParameter *>::iterator
10092  {
10093  return m_listCustom.begin();
10094  }
10095 
10097  inline std::list<CParameter *>::iterator
10098  endCustom (void)
10099  {
10100  return m_listCustom.end();
10101  }
10102 
10104  inline void
10106  {
10107  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10108  }
10109 
10111  inline int
10113  {
10114  return (int) (m_listCustom.size());
10115  }
10116 
10117  EResultCode
10119  addCustom (
10120  CParameter * pValue);
10121 
10122 
10123 };
10124 
10125 
10151 class CImpinjAntennaEventConfiguration : public CParameter
10152 {
10153  public:
10156 
10159 
10160  static const CFieldDescriptor * const
10161  s_apFieldDescriptorTable[];
10162 
10163  static const CTypeDescriptor
10164  s_typeDescriptor;
10165 
10166  void
10167  decodeFields (
10168  CDecoderStream * pDecoderStream);
10169 
10170  void
10171  assimilateSubParameters (
10172  CErrorDetails * pError);
10173 
10174  void
10175  encode (
10176  CEncoderStream * pEncoderStream) const;
10177 
10178 
10179  llrp_bool_t
10180  isAllowedIn (
10181  const CTypeDescriptor * pEnclosingElementType) const;
10182 
10183 
10184  static CElement *
10185  s_construct (void);
10186 
10187  static void
10188  s_decodeFields (
10189  CDecoderStream * pDecoderStream,
10190  CElement * pElement);
10192 
10193 
10194  protected:
10195  llrp_u1_t m_EnableAntennaAttemptNotification;
10196 
10199  public:
10200  static const CFieldDescriptor
10201  s_fdEnableAntennaAttemptNotification;
10203 
10205  inline llrp_u1_t
10207  {
10208  return m_EnableAntennaAttemptNotification;
10209  }
10210 
10212  inline void
10214  llrp_u1_t value)
10215  {
10216  m_EnableAntennaAttemptNotification = value;
10217  }
10218 
10219 
10220 
10221  protected:
10222  std::list<CParameter *> m_listCustom;
10223 
10224  public:
10226  inline std::list<CParameter *>::iterator
10228  {
10229  return m_listCustom.begin();
10230  }
10231 
10233  inline std::list<CParameter *>::iterator
10234  endCustom (void)
10235  {
10236  return m_listCustom.end();
10237  }
10238 
10240  inline void
10242  {
10243  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10244  }
10245 
10247  inline int
10249  {
10250  return (int) (m_listCustom.size());
10251  }
10252 
10253  EResultCode
10255  addCustom (
10256  CParameter * pValue);
10257 
10258 
10259 };
10260 
10261 
10286 class CImpinjAntennaAttemptEvent : public CParameter
10287 {
10288  public:
10291 
10294 
10295  static const CFieldDescriptor * const
10296  s_apFieldDescriptorTable[];
10297 
10298  static const CTypeDescriptor
10299  s_typeDescriptor;
10300 
10301  void
10302  decodeFields (
10303  CDecoderStream * pDecoderStream);
10304 
10305  void
10306  assimilateSubParameters (
10307  CErrorDetails * pError);
10308 
10309  void
10310  encode (
10311  CEncoderStream * pEncoderStream) const;
10312 
10313 
10314  llrp_bool_t
10315  isAllowedIn (
10316  const CTypeDescriptor * pEnclosingElementType) const;
10317 
10318 
10319  static CElement *
10320  s_construct (void);
10321 
10322  static void
10323  s_decodeFields (
10324  CDecoderStream * pDecoderStream,
10325  CElement * pElement);
10327 
10328 
10329  protected:
10330  llrp_u16_t m_AntennaID;
10331 
10334  public:
10335  static const CFieldDescriptor
10336  s_fdAntennaID;
10338 
10340  inline llrp_u16_t
10342  {
10343  return m_AntennaID;
10344  }
10345 
10347  inline void
10349  llrp_u16_t value)
10350  {
10351  m_AntennaID = value;
10352  }
10353 
10354 
10355 
10356  protected:
10357  std::list<CParameter *> m_listCustom;
10358 
10359  public:
10361  inline std::list<CParameter *>::iterator
10363  {
10364  return m_listCustom.begin();
10365  }
10366 
10368  inline std::list<CParameter *>::iterator
10369  endCustom (void)
10370  {
10371  return m_listCustom.end();
10372  }
10373 
10375  inline void
10377  {
10378  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10379  }
10380 
10382  inline int
10384  {
10385  return (int) (m_listCustom.size());
10386  }
10387 
10388  EResultCode
10390  addCustom (
10391  CParameter * pValue);
10392 
10393 
10394 };
10395 
10396 
10424 class CImpinjHubConfiguration : public CParameter
10425 {
10426  public:
10427  CImpinjHubConfiguration (void);
10428  ~CImpinjHubConfiguration (void);
10429 
10432 
10433  static const CFieldDescriptor * const
10434  s_apFieldDescriptorTable[];
10435 
10436  static const CTypeDescriptor
10437  s_typeDescriptor;
10438 
10439  void
10440  decodeFields (
10441  CDecoderStream * pDecoderStream);
10442 
10443  void
10444  assimilateSubParameters (
10445  CErrorDetails * pError);
10446 
10447  void
10448  encode (
10449  CEncoderStream * pEncoderStream) const;
10450 
10451 
10452  llrp_bool_t
10453  isAllowedIn (
10454  const CTypeDescriptor * pEnclosingElementType) const;
10455 
10456 
10457  static CElement *
10458  s_construct (void);
10459 
10460  static void
10461  s_decodeFields (
10462  CDecoderStream * pDecoderStream,
10463  CElement * pElement);
10465 
10466 
10467  protected:
10468  llrp_u16_t m_HubID;
10469 
10472  public:
10473  static const CFieldDescriptor
10474  s_fdHubID;
10476 
10478  inline llrp_u16_t
10479  getHubID (void)
10480  {
10481  return m_HubID;
10482  }
10483 
10485  inline void
10487  llrp_u16_t value)
10488  {
10489  m_HubID = value;
10490  }
10491 
10492 
10493  protected:
10494  EImpinjHubConnectedType m_eConnected;
10495 
10498  public:
10499  static const CFieldDescriptor
10500  s_fdConnected;
10502 
10504  inline EImpinjHubConnectedType
10506  {
10507  return m_eConnected;
10508  }
10509 
10511  inline void
10513  EImpinjHubConnectedType value)
10514  {
10515  m_eConnected = value;
10516  }
10517 
10518 
10519  protected:
10520  EImpinjHubFaultType m_eFault;
10521 
10524  public:
10525  static const CFieldDescriptor
10526  s_fdFault;
10528 
10530  inline EImpinjHubFaultType
10531  getFault (void)
10532  {
10533  return m_eFault;
10534  }
10535 
10537  inline void
10539  EImpinjHubFaultType value)
10540  {
10541  m_eFault = value;
10542  }
10543 
10544 
10545 
10546  protected:
10547  std::list<CParameter *> m_listCustom;
10548 
10549  public:
10551  inline std::list<CParameter *>::iterator
10553  {
10554  return m_listCustom.begin();
10555  }
10556 
10558  inline std::list<CParameter *>::iterator
10559  endCustom (void)
10560  {
10561  return m_listCustom.end();
10562  }
10563 
10565  inline void
10567  {
10568  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10569  }
10570 
10572  inline int
10574  {
10575  return (int) (m_listCustom.size());
10576  }
10577 
10578  EResultCode
10580  addCustom (
10581  CParameter * pValue);
10582 
10583 
10584 };
10585 
10586 
10610 class CImpinjDiagnosticReport : public CParameter
10611 {
10612  public:
10613  CImpinjDiagnosticReport (void);
10614  ~CImpinjDiagnosticReport (void);
10615 
10618 
10619  static const CFieldDescriptor * const
10620  s_apFieldDescriptorTable[];
10621 
10622  static const CTypeDescriptor
10623  s_typeDescriptor;
10624 
10625  void
10626  decodeFields (
10627  CDecoderStream * pDecoderStream);
10628 
10629  void
10630  assimilateSubParameters (
10631  CErrorDetails * pError);
10632 
10633  void
10634  encode (
10635  CEncoderStream * pEncoderStream) const;
10636 
10637 
10638  llrp_bool_t
10639  isAllowedIn (
10640  const CTypeDescriptor * pEnclosingElementType) const;
10641 
10642 
10643  static CElement *
10644  s_construct (void);
10645 
10646  static void
10647  s_decodeFields (
10648  CDecoderStream * pDecoderStream,
10649  CElement * pElement);
10651 
10652 
10653  protected:
10654  llrp_u32v_t m_Metric;
10655 
10658  public:
10659  static const CFieldDescriptor
10660  s_fdMetric;
10662 
10664  inline llrp_u32v_t
10665  getMetric (void)
10666  {
10667  return m_Metric;
10668  }
10669 
10671  inline void
10673  llrp_u32v_t value)
10674  {
10675  m_Metric = value;
10676  }
10677 
10678 
10679 
10680 };
10681 
10682 
10721 class CImpinjPlacementConfiguration : public CParameter
10722 {
10723  public:
10726 
10729 
10730  static const CFieldDescriptor * const
10731  s_apFieldDescriptorTable[];
10732 
10733  static const CTypeDescriptor
10734  s_typeDescriptor;
10735 
10736  void
10737  decodeFields (
10738  CDecoderStream * pDecoderStream);
10739 
10740  void
10741  assimilateSubParameters (
10742  CErrorDetails * pError);
10743 
10744  void
10745  encode (
10746  CEncoderStream * pEncoderStream) const;
10747 
10748 
10749  llrp_bool_t
10750  isAllowedIn (
10751  const CTypeDescriptor * pEnclosingElementType) const;
10752 
10753 
10754  static CElement *
10755  s_construct (void);
10756 
10757  static void
10758  s_decodeFields (
10759  CDecoderStream * pDecoderStream,
10760  CElement * pElement);
10762 
10763 
10764  protected:
10765  llrp_u16_t m_HeightCm;
10766 
10769  public:
10770  static const CFieldDescriptor
10771  s_fdHeightCm;
10773 
10775  inline llrp_u16_t
10777  {
10778  return m_HeightCm;
10779  }
10780 
10782  inline void
10784  llrp_u16_t value)
10785  {
10786  m_HeightCm = value;
10787  }
10788 
10789 
10790  protected:
10791  llrp_s32_t m_FacilityXLocationCm;
10792 
10795  public:
10796  static const CFieldDescriptor
10797  s_fdFacilityXLocationCm;
10799 
10801  inline llrp_s32_t
10803  {
10804  return m_FacilityXLocationCm;
10805  }
10806 
10808  inline void
10810  llrp_s32_t value)
10811  {
10812  m_FacilityXLocationCm = value;
10813  }
10814 
10815 
10816  protected:
10817  llrp_s32_t m_FacilityYLocationCm;
10818 
10821  public:
10822  static const CFieldDescriptor
10823  s_fdFacilityYLocationCm;
10825 
10827  inline llrp_s32_t
10829  {
10830  return m_FacilityYLocationCm;
10831  }
10832 
10834  inline void
10836  llrp_s32_t value)
10837  {
10838  m_FacilityYLocationCm = value;
10839  }
10840 
10841 
10842  protected:
10843  llrp_s16_t m_OrientationDegrees;
10844 
10847  public:
10848  static const CFieldDescriptor
10849  s_fdOrientationDegrees;
10851 
10853  inline llrp_s16_t
10855  {
10856  return m_OrientationDegrees;
10857  }
10858 
10860  inline void
10862  llrp_s16_t value)
10863  {
10864  m_OrientationDegrees = value;
10865  }
10866 
10867 
10868 
10869  protected:
10870  std::list<CParameter *> m_listCustom;
10871 
10872  public:
10874  inline std::list<CParameter *>::iterator
10876  {
10877  return m_listCustom.begin();
10878  }
10879 
10881  inline std::list<CParameter *>::iterator
10882  endCustom (void)
10883  {
10884  return m_listCustom.end();
10885  }
10886 
10888  inline void
10890  {
10891  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10892  }
10893 
10895  inline int
10897  {
10898  return (int) (m_listCustom.size());
10899  }
10900 
10901  EResultCode
10903  addCustom (
10904  CParameter * pValue);
10905 
10906 
10907 };
10908 
10909 
10940 class CImpinjLISpec : public CParameter
10941 {
10942  public:
10943  CImpinjLISpec (void);
10944  ~CImpinjLISpec (void);
10945 
10948 
10949  static const CFieldDescriptor * const
10950  s_apFieldDescriptorTable[];
10951 
10952  static const CTypeDescriptor
10953  s_typeDescriptor;
10954 
10955  void
10956  decodeFields (
10957  CDecoderStream * pDecoderStream);
10958 
10959  void
10960  assimilateSubParameters (
10961  CErrorDetails * pError);
10962 
10963  void
10964  encode (
10965  CEncoderStream * pEncoderStream) const;
10966 
10967 
10968  llrp_bool_t
10969  isAllowedIn (
10970  const CTypeDescriptor * pEnclosingElementType) const;
10971 
10972 
10973  static CElement *
10974  s_construct (void);
10975 
10976  static void
10977  s_decodeFields (
10978  CDecoderStream * pDecoderStream,
10979  CElement * pElement);
10981 
10982 
10983 
10984  protected:
10985  CImpinjLocationConfig * m_pImpinjLocationConfig;
10986 
10987  public:
10989  inline CImpinjLocationConfig *
10991  {
10992  return m_pImpinjLocationConfig;
10993  }
10994 
10996  EResultCode
10997  setImpinjLocationConfig (
10998  CImpinjLocationConfig * pValue);
10999 
11000 
11001  protected:
11002  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
11003 
11004  public:
11006  inline CImpinjC1G2LocationConfig *
11008  {
11009  return m_pImpinjC1G2LocationConfig;
11010  }
11011 
11013  EResultCode
11014  setImpinjC1G2LocationConfig (
11015  CImpinjC1G2LocationConfig * pValue);
11016 
11017 
11018  protected:
11019  CImpinjLocationReporting * m_pImpinjLocationReporting;
11020 
11021  public:
11023  inline CImpinjLocationReporting *
11025  {
11026  return m_pImpinjLocationReporting;
11027  }
11028 
11030  EResultCode
11031  setImpinjLocationReporting (
11032  CImpinjLocationReporting * pValue);
11033 
11034 
11035  protected:
11036  std::list<CParameter *> m_listCustom;
11037 
11038  public:
11040  inline std::list<CParameter *>::iterator
11042  {
11043  return m_listCustom.begin();
11044  }
11045 
11047  inline std::list<CParameter *>::iterator
11048  endCustom (void)
11049  {
11050  return m_listCustom.end();
11051  }
11052 
11054  inline void
11056  {
11057  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11058  }
11059 
11061  inline int
11063  {
11064  return (int) (m_listCustom.size());
11065  }
11066 
11067  EResultCode
11069  addCustom (
11070  CParameter * pValue);
11071 
11072 
11073 };
11074 
11075 
11121 class CImpinjLocationConfig : public CParameter
11122 {
11123  public:
11124  CImpinjLocationConfig (void);
11125  ~CImpinjLocationConfig (void);
11126 
11129 
11130  static const CFieldDescriptor * const
11131  s_apFieldDescriptorTable[];
11132 
11133  static const CTypeDescriptor
11134  s_typeDescriptor;
11135 
11136  void
11137  decodeFields (
11138  CDecoderStream * pDecoderStream);
11139 
11140  void
11141  assimilateSubParameters (
11142  CErrorDetails * pError);
11143 
11144  void
11145  encode (
11146  CEncoderStream * pEncoderStream) const;
11147 
11148 
11149  llrp_bool_t
11150  isAllowedIn (
11151  const CTypeDescriptor * pEnclosingElementType) const;
11152 
11153 
11154  static CElement *
11155  s_construct (void);
11156 
11157  static void
11158  s_decodeFields (
11159  CDecoderStream * pDecoderStream,
11160  CElement * pElement);
11162 
11163 
11164  protected:
11165  llrp_u16_t m_ComputeWindowSeconds;
11166 
11169  public:
11170  static const CFieldDescriptor
11171  s_fdComputeWindowSeconds;
11173 
11175  inline llrp_u16_t
11177  {
11178  return m_ComputeWindowSeconds;
11179  }
11180 
11182  inline void
11184  llrp_u16_t value)
11185  {
11186  m_ComputeWindowSeconds = value;
11187  }
11188 
11189 
11190  protected:
11191  llrp_u16_t m_TagAgeIntervalSeconds;
11192 
11195  public:
11196  static const CFieldDescriptor
11197  s_fdTagAgeIntervalSeconds;
11199 
11201  inline llrp_u16_t
11203  {
11204  return m_TagAgeIntervalSeconds;
11205  }
11206 
11208  inline void
11210  llrp_u16_t value)
11211  {
11212  m_TagAgeIntervalSeconds = value;
11213  }
11214 
11215 
11216  protected:
11217  llrp_u16_t m_UpdateIntervalSeconds;
11218 
11221  public:
11222  static const CFieldDescriptor
11223  s_fdUpdateIntervalSeconds;
11225 
11227  inline llrp_u16_t
11229  {
11230  return m_UpdateIntervalSeconds;
11231  }
11232 
11234  inline void
11236  llrp_u16_t value)
11237  {
11238  m_UpdateIntervalSeconds = value;
11239  }
11240 
11241 
11242 
11243  protected:
11244  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
11245 
11246  public:
11248  inline CImpinjDisabledAntennas *
11250  {
11251  return m_pImpinjDisabledAntennas;
11252  }
11253 
11255  EResultCode
11256  setImpinjDisabledAntennas (
11257  CImpinjDisabledAntennas * pValue);
11258 
11259 
11260  protected:
11261  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
11262 
11263  public:
11267  {
11268  return m_pImpinjLocationAlgorithmControl;
11269  }
11270 
11272  EResultCode
11273  setImpinjLocationAlgorithmControl (
11275 
11276 
11277  protected:
11278  std::list<CParameter *> m_listCustom;
11279 
11280  public:
11282  inline std::list<CParameter *>::iterator
11284  {
11285  return m_listCustom.begin();
11286  }
11287 
11289  inline std::list<CParameter *>::iterator
11290  endCustom (void)
11291  {
11292  return m_listCustom.end();
11293  }
11294 
11296  inline void
11298  {
11299  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11300  }
11301 
11303  inline int
11305  {
11306  return (int) (m_listCustom.size());
11307  }
11308 
11309  EResultCode
11311  addCustom (
11312  CParameter * pValue);
11313 
11314 
11315 };
11316 
11317 
11360 class CImpinjC1G2LocationConfig : public CParameter
11361 {
11362  public:
11364  ~CImpinjC1G2LocationConfig (void);
11365 
11368 
11369  static const CFieldDescriptor * const
11370  s_apFieldDescriptorTable[];
11371 
11372  static const CTypeDescriptor
11373  s_typeDescriptor;
11374 
11375  void
11376  decodeFields (
11377  CDecoderStream * pDecoderStream);
11378 
11379  void
11380  assimilateSubParameters (
11381  CErrorDetails * pError);
11382 
11383  void
11384  encode (
11385  CEncoderStream * pEncoderStream) const;
11386 
11387 
11388  llrp_bool_t
11389  isAllowedIn (
11390  const CTypeDescriptor * pEnclosingElementType) const;
11391 
11392 
11393  static CElement *
11394  s_construct (void);
11395 
11396  static void
11397  s_decodeFields (
11398  CDecoderStream * pDecoderStream,
11399  CElement * pElement);
11401 
11402 
11403  protected:
11404  llrp_u16_t m_ModeIndex;
11405 
11408  public:
11409  static const CFieldDescriptor
11410  s_fdModeIndex;
11412 
11414  inline llrp_u16_t
11416  {
11417  return m_ModeIndex;
11418  }
11419 
11421  inline void
11423  llrp_u16_t value)
11424  {
11425  m_ModeIndex = value;
11426  }
11427 
11428 
11429  protected:
11430  llrp_u2_t m_Session;
11431 
11434  public:
11435  static const CFieldDescriptor
11436  s_fdSession;
11438 
11440  inline llrp_u2_t
11441  getSession (void)
11442  {
11443  return m_Session;
11444  }
11445 
11447  inline void
11449  llrp_u2_t value)
11450  {
11451  m_Session = value;
11452  }
11453 
11454 
11455 
11456  protected:
11457  std::list<CC1G2Filter *> m_listC1G2Filter;
11458 
11459  public:
11461  inline std::list<CC1G2Filter *>::iterator
11463  {
11464  return m_listC1G2Filter.begin();
11465  }
11466 
11468  inline std::list<CC1G2Filter *>::iterator
11470  {
11471  return m_listC1G2Filter.end();
11472  }
11473 
11475  inline void
11477  {
11478  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
11479  }
11480 
11482  inline int
11484  {
11485  return (int) (m_listC1G2Filter.size());
11486  }
11487 
11488  EResultCode
11490  addC1G2Filter (
11491  CC1G2Filter * pValue);
11492 
11493 
11494  protected:
11495  CImpinjTransmitPower * m_pImpinjTransmitPower;
11496 
11497  public:
11499  inline CImpinjTransmitPower *
11501  {
11502  return m_pImpinjTransmitPower;
11503  }
11504 
11506  EResultCode
11507  setImpinjTransmitPower (
11508  CImpinjTransmitPower * pValue);
11509 
11510 
11511  protected:
11512  std::list<CParameter *> m_listCustom;
11513 
11514  public:
11516  inline std::list<CParameter *>::iterator
11518  {
11519  return m_listCustom.begin();
11520  }
11521 
11523  inline std::list<CParameter *>::iterator
11524  endCustom (void)
11525  {
11526  return m_listCustom.end();
11527  }
11528 
11530  inline void
11532  {
11533  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11534  }
11535 
11537  inline int
11539  {
11540  return (int) (m_listCustom.size());
11541  }
11542 
11543  EResultCode
11545  addCustom (
11546  CParameter * pValue);
11547 
11548 
11549 };
11550 
11551 
11593 class CImpinjLocationReporting : public CParameter
11594 {
11595  public:
11596  CImpinjLocationReporting (void);
11597  ~CImpinjLocationReporting (void);
11598 
11601 
11602  static const CFieldDescriptor * const
11603  s_apFieldDescriptorTable[];
11604 
11605  static const CTypeDescriptor
11606  s_typeDescriptor;
11607 
11608  void
11609  decodeFields (
11610  CDecoderStream * pDecoderStream);
11611 
11612  void
11613  assimilateSubParameters (
11614  CErrorDetails * pError);
11615 
11616  void
11617  encode (
11618  CEncoderStream * pEncoderStream) const;
11619 
11620 
11621  llrp_bool_t
11622  isAllowedIn (
11623  const CTypeDescriptor * pEnclosingElementType) const;
11624 
11625 
11626  static CElement *
11627  s_construct (void);
11628 
11629  static void
11630  s_decodeFields (
11631  CDecoderStream * pDecoderStream,
11632  CElement * pElement);
11634 
11635 
11636  protected:
11637  llrp_u1_t m_EnableUpdateReport;
11638 
11641  public:
11642  static const CFieldDescriptor
11643  s_fdEnableUpdateReport;
11645 
11647  inline llrp_u1_t
11649  {
11650  return m_EnableUpdateReport;
11651  }
11652 
11654  inline void
11656  llrp_u1_t value)
11657  {
11658  m_EnableUpdateReport = value;
11659  }
11660 
11661 
11662  protected:
11663  llrp_u1_t m_EnableEntryReport;
11664 
11667  public:
11668  static const CFieldDescriptor
11669  s_fdEnableEntryReport;
11671 
11673  inline llrp_u1_t
11675  {
11676  return m_EnableEntryReport;
11677  }
11678 
11680  inline void
11682  llrp_u1_t value)
11683  {
11684  m_EnableEntryReport = value;
11685  }
11686 
11687 
11688  protected:
11689  llrp_u1_t m_EnableExitReport;
11690 
11693  public:
11694  static const CFieldDescriptor
11695  s_fdEnableExitReport;
11697 
11699  inline llrp_u1_t
11701  {
11702  return m_EnableExitReport;
11703  }
11704 
11706  inline void
11708  llrp_u1_t value)
11709  {
11710  m_EnableExitReport = value;
11711  }
11712 
11713 
11714  protected:
11715  llrp_u1_t m_EnableDiagnosticReport;
11716 
11719  public:
11720  static const CFieldDescriptor
11721  s_fdEnableDiagnosticReport;
11723 
11725  inline llrp_u1_t
11727  {
11728  return m_EnableDiagnosticReport;
11729  }
11730 
11732  inline void
11734  llrp_u1_t value)
11735  {
11736  m_EnableDiagnosticReport = value;
11737  }
11738 
11739 
11740 
11741  protected:
11742  std::list<CParameter *> m_listCustom;
11743 
11744  public:
11746  inline std::list<CParameter *>::iterator
11748  {
11749  return m_listCustom.begin();
11750  }
11751 
11753  inline std::list<CParameter *>::iterator
11754  endCustom (void)
11755  {
11756  return m_listCustom.end();
11757  }
11758 
11760  inline void
11762  {
11763  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11764  }
11765 
11767  inline int
11769  {
11770  return (int) (m_listCustom.size());
11771  }
11772 
11773  EResultCode
11775  addCustom (
11776  CParameter * pValue);
11777 
11778 
11779 };
11780 
11781 
11812 class CImpinjLocationConfidence : public CParameter
11813 {
11814  public:
11816  ~CImpinjLocationConfidence (void);
11817 
11820 
11821  static const CFieldDescriptor * const
11822  s_apFieldDescriptorTable[];
11823 
11824  static const CTypeDescriptor
11825  s_typeDescriptor;
11826 
11827  void
11828  decodeFields (
11829  CDecoderStream * pDecoderStream);
11830 
11831  void
11832  assimilateSubParameters (
11833  CErrorDetails * pError);
11834 
11835  void
11836  encode (
11837  CEncoderStream * pEncoderStream) const;
11838 
11839 
11840  llrp_bool_t
11841  isAllowedIn (
11842  const CTypeDescriptor * pEnclosingElementType) const;
11843 
11844 
11845  static CElement *
11846  s_construct (void);
11847 
11848  static void
11849  s_decodeFields (
11850  CDecoderStream * pDecoderStream,
11851  CElement * pElement);
11853 
11854 
11855  protected:
11856  llrp_u16_t m_ReadCount;
11857 
11860  public:
11861  static const CFieldDescriptor
11862  s_fdReadCount;
11864 
11866  inline llrp_u16_t
11868  {
11869  return m_ReadCount;
11870  }
11871 
11873  inline void
11875  llrp_u16_t value)
11876  {
11877  m_ReadCount = value;
11878  }
11879 
11880 
11881  protected:
11882  llrp_u32v_t m_ConfidenceData;
11883 
11886  public:
11887  static const CFieldDescriptor
11888  s_fdConfidenceData;
11890 
11892  inline llrp_u32v_t
11894  {
11895  return m_ConfidenceData;
11896  }
11897 
11899  inline void
11901  llrp_u32v_t value)
11902  {
11903  m_ConfidenceData = value;
11904  }
11905 
11906 
11907 
11908  protected:
11909  std::list<CParameter *> m_listCustom;
11910 
11911  public:
11913  inline std::list<CParameter *>::iterator
11915  {
11916  return m_listCustom.begin();
11917  }
11918 
11920  inline std::list<CParameter *>::iterator
11921  endCustom (void)
11922  {
11923  return m_listCustom.end();
11924  }
11925 
11927  inline void
11929  {
11930  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11931  }
11932 
11934  inline int
11936  {
11937  return (int) (m_listCustom.size());
11938  }
11939 
11940  EResultCode
11942  addCustom (
11943  CParameter * pValue);
11944 
11945 
11946 };
11947 
11948 
11986 class CImpinjLocationReportData : public CParameter
11987 {
11988  public:
11990  ~CImpinjLocationReportData (void);
11991 
11994 
11995  static const CFieldDescriptor * const
11996  s_apFieldDescriptorTable[];
11997 
11998  static const CTypeDescriptor
11999  s_typeDescriptor;
12000 
12001  void
12002  decodeFields (
12003  CDecoderStream * pDecoderStream);
12004 
12005  void
12006  assimilateSubParameters (
12007  CErrorDetails * pError);
12008 
12009  void
12010  encode (
12011  CEncoderStream * pEncoderStream) const;
12012 
12013 
12014  llrp_bool_t
12015  isAllowedIn (
12016  const CTypeDescriptor * pEnclosingElementType) const;
12017 
12018 
12019  static CElement *
12020  s_construct (void);
12021 
12022  static void
12023  s_decodeFields (
12024  CDecoderStream * pDecoderStream,
12025  CElement * pElement);
12027 
12028 
12029  protected:
12030  llrp_u64_t m_LastSeenTimestampUTC;
12031 
12034  public:
12035  static const CFieldDescriptor
12036  s_fdLastSeenTimestampUTC;
12038 
12040  inline llrp_u64_t
12042  {
12043  return m_LastSeenTimestampUTC;
12044  }
12045 
12047  inline void
12049  llrp_u64_t value)
12050  {
12051  m_LastSeenTimestampUTC = value;
12052  }
12053 
12054 
12055  protected:
12056  llrp_s32_t m_LocXCentimeters;
12057 
12060  public:
12061  static const CFieldDescriptor
12062  s_fdLocXCentimeters;
12064 
12066  inline llrp_s32_t
12068  {
12069  return m_LocXCentimeters;
12070  }
12071 
12073  inline void
12075  llrp_s32_t value)
12076  {
12077  m_LocXCentimeters = value;
12078  }
12079 
12080 
12081  protected:
12082  llrp_s32_t m_LocYCentimeters;
12083 
12086  public:
12087  static const CFieldDescriptor
12088  s_fdLocYCentimeters;
12090 
12092  inline llrp_s32_t
12094  {
12095  return m_LocYCentimeters;
12096  }
12097 
12099  inline void
12101  llrp_s32_t value)
12102  {
12103  m_LocYCentimeters = value;
12104  }
12105 
12106 
12107  protected:
12108  EImpinjLocationReportType m_eType;
12109 
12112  public:
12113  static const CFieldDescriptor
12114  s_fdType;
12116 
12118  inline EImpinjLocationReportType
12119  getType (void)
12120  {
12121  return m_eType;
12122  }
12123 
12125  inline void
12127  EImpinjLocationReportType value)
12128  {
12129  m_eType = value;
12130  }
12131 
12132 
12133 
12134  protected:
12135  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
12136 
12137  public:
12139  inline CImpinjLocationConfidence *
12141  {
12142  return m_pImpinjLocationConfidence;
12143  }
12144 
12146  EResultCode
12147  setImpinjLocationConfidence (
12148  CImpinjLocationConfidence * pValue);
12149 
12150 
12151  protected:
12152  std::list<CParameter *> m_listCustom;
12153 
12154  public:
12156  inline std::list<CParameter *>::iterator
12158  {
12159  return m_listCustom.begin();
12160  }
12161 
12163  inline std::list<CParameter *>::iterator
12164  endCustom (void)
12165  {
12166  return m_listCustom.end();
12167  }
12168 
12170  inline void
12172  {
12173  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12174  }
12175 
12177  inline int
12179  {
12180  return (int) (m_listCustom.size());
12181  }
12182 
12183  EResultCode
12185  addCustom (
12186  CParameter * pValue);
12187 
12188 
12189 };
12190 
12191 
12224 class CImpinjDISpec : public CParameter
12225 {
12226  public:
12227  CImpinjDISpec (void);
12228  ~CImpinjDISpec (void);
12229 
12232 
12233  static const CFieldDescriptor * const
12234  s_apFieldDescriptorTable[];
12235 
12236  static const CTypeDescriptor
12237  s_typeDescriptor;
12238 
12239  void
12240  decodeFields (
12241  CDecoderStream * pDecoderStream);
12242 
12243  void
12244  assimilateSubParameters (
12245  CErrorDetails * pError);
12246 
12247  void
12248  encode (
12249  CEncoderStream * pEncoderStream) const;
12250 
12251 
12252  llrp_bool_t
12253  isAllowedIn (
12254  const CTypeDescriptor * pEnclosingElementType) const;
12255 
12256 
12257  static CElement *
12258  s_construct (void);
12259 
12260  static void
12261  s_decodeFields (
12262  CDecoderStream * pDecoderStream,
12263  CElement * pElement);
12265 
12266 
12267 
12268  protected:
12269  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
12270 
12271  public:
12273  inline CImpinjDirectionSectors *
12275  {
12276  return m_pImpinjDirectionSectors;
12277  }
12278 
12280  EResultCode
12281  setImpinjDirectionSectors (
12282  CImpinjDirectionSectors * pValue);
12283 
12284 
12285  protected:
12286  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
12287 
12288  public:
12290  inline CImpinjDirectionConfig *
12292  {
12293  return m_pImpinjDirectionConfig;
12294  }
12295 
12297  EResultCode
12298  setImpinjDirectionConfig (
12299  CImpinjDirectionConfig * pValue);
12300 
12301 
12302  protected:
12303  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
12304 
12305  public:
12309  {
12310  return m_pImpinjC1G2DirectionConfig;
12311  }
12312 
12314  EResultCode
12315  setImpinjC1G2DirectionConfig (
12316  CImpinjC1G2DirectionConfig * pValue);
12317 
12318 
12319  protected:
12320  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
12321 
12322  public:
12324  inline CImpinjDirectionReporting *
12326  {
12327  return m_pImpinjDirectionReporting;
12328  }
12329 
12331  EResultCode
12332  setImpinjDirectionReporting (
12333  CImpinjDirectionReporting * pValue);
12334 
12335 
12336  protected:
12337  std::list<CParameter *> m_listCustom;
12338 
12339  public:
12341  inline std::list<CParameter *>::iterator
12343  {
12344  return m_listCustom.begin();
12345  }
12346 
12348  inline std::list<CParameter *>::iterator
12349  endCustom (void)
12350  {
12351  return m_listCustom.end();
12352  }
12353 
12355  inline void
12357  {
12358  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12359  }
12360 
12362  inline int
12364  {
12365  return (int) (m_listCustom.size());
12366  }
12367 
12368  EResultCode
12370  addCustom (
12371  CParameter * pValue);
12372 
12373 
12374 };
12375 
12376 
12404 class CImpinjDirectionSectors : public CParameter
12405 {
12406  public:
12407  CImpinjDirectionSectors (void);
12408  ~CImpinjDirectionSectors (void);
12409 
12412 
12413  static const CFieldDescriptor * const
12414  s_apFieldDescriptorTable[];
12415 
12416  static const CTypeDescriptor
12417  s_typeDescriptor;
12418 
12419  void
12420  decodeFields (
12421  CDecoderStream * pDecoderStream);
12422 
12423  void
12424  assimilateSubParameters (
12425  CErrorDetails * pError);
12426 
12427  void
12428  encode (
12429  CEncoderStream * pEncoderStream) const;
12430 
12431 
12432  llrp_bool_t
12433  isAllowedIn (
12434  const CTypeDescriptor * pEnclosingElementType) const;
12435 
12436 
12437  static CElement *
12438  s_construct (void);
12439 
12440  static void
12441  s_decodeFields (
12442  CDecoderStream * pDecoderStream,
12443  CElement * pElement);
12445 
12446 
12447  protected:
12448  llrp_u16v_t m_EnabledSectorIDs;
12449 
12452  public:
12453  static const CFieldDescriptor
12454  s_fdEnabledSectorIDs;
12456 
12458  inline llrp_u16v_t
12460  {
12461  return m_EnabledSectorIDs;
12462  }
12463 
12465  inline void
12467  llrp_u16v_t value)
12468  {
12469  m_EnabledSectorIDs = value;
12470  }
12471 
12472 
12473 
12474  protected:
12475  std::list<CParameter *> m_listCustom;
12476 
12477  public:
12479  inline std::list<CParameter *>::iterator
12481  {
12482  return m_listCustom.begin();
12483  }
12484 
12486  inline std::list<CParameter *>::iterator
12487  endCustom (void)
12488  {
12489  return m_listCustom.end();
12490  }
12491 
12493  inline void
12495  {
12496  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12497  }
12498 
12500  inline int
12502  {
12503  return (int) (m_listCustom.size());
12504  }
12505 
12506  EResultCode
12508  addCustom (
12509  CParameter * pValue);
12510 
12511 
12512 };
12513 
12514 
12553 class CImpinjDirectionConfig : public CParameter
12554 {
12555  public:
12556  CImpinjDirectionConfig (void);
12557  ~CImpinjDirectionConfig (void);
12558 
12561 
12562  static const CFieldDescriptor * const
12563  s_apFieldDescriptorTable[];
12564 
12565  static const CTypeDescriptor
12566  s_typeDescriptor;
12567 
12568  void
12569  decodeFields (
12570  CDecoderStream * pDecoderStream);
12571 
12572  void
12573  assimilateSubParameters (
12574  CErrorDetails * pError);
12575 
12576  void
12577  encode (
12578  CEncoderStream * pEncoderStream) const;
12579 
12580 
12581  llrp_bool_t
12582  isAllowedIn (
12583  const CTypeDescriptor * pEnclosingElementType) const;
12584 
12585 
12586  static CElement *
12587  s_construct (void);
12588 
12589  static void
12590  s_decodeFields (
12591  CDecoderStream * pDecoderStream,
12592  CElement * pElement);
12594 
12595 
12596  protected:
12597  llrp_u16_t m_TagAgeIntervalSeconds;
12598 
12601  public:
12602  static const CFieldDescriptor
12603  s_fdTagAgeIntervalSeconds;
12605 
12607  inline llrp_u16_t
12609  {
12610  return m_TagAgeIntervalSeconds;
12611  }
12612 
12614  inline void
12616  llrp_u16_t value)
12617  {
12618  m_TagAgeIntervalSeconds = value;
12619  }
12620 
12621 
12622  protected:
12623  llrp_u16_t m_UpdateIntervalSeconds;
12624 
12627  public:
12628  static const CFieldDescriptor
12629  s_fdUpdateIntervalSeconds;
12631 
12633  inline llrp_u16_t
12635  {
12636  return m_UpdateIntervalSeconds;
12637  }
12638 
12640  inline void
12642  llrp_u16_t value)
12643  {
12644  m_UpdateIntervalSeconds = value;
12645  }
12646 
12647 
12648  protected:
12649  EImpinjDirectionFieldOfView m_eFieldOfView;
12650 
12653  public:
12654  static const CFieldDescriptor
12655  s_fdFieldOfView;
12657 
12659  inline EImpinjDirectionFieldOfView
12661  {
12662  return m_eFieldOfView;
12663  }
12664 
12666  inline void
12668  EImpinjDirectionFieldOfView value)
12669  {
12670  m_eFieldOfView = value;
12671  }
12672 
12673 
12674 
12675  protected:
12676  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12677 
12678  public:
12682  {
12683  return m_pImpinjDirectionUserTagPopulationLimit;
12684  }
12685 
12687  EResultCode
12688  setImpinjDirectionUserTagPopulationLimit (
12690 
12691 
12692  protected:
12693  std::list<CParameter *> m_listCustom;
12694 
12695  public:
12697  inline std::list<CParameter *>::iterator
12699  {
12700  return m_listCustom.begin();
12701  }
12702 
12704  inline std::list<CParameter *>::iterator
12705  endCustom (void)
12706  {
12707  return m_listCustom.end();
12708  }
12709 
12711  inline void
12713  {
12714  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12715  }
12716 
12718  inline int
12720  {
12721  return (int) (m_listCustom.size());
12722  }
12723 
12724  EResultCode
12726  addCustom (
12727  CParameter * pValue);
12728 
12729 
12730 };
12731 
12732 
12755 class CImpinjDirectionUserTagPopulationLimit : public CParameter
12756 {
12757  public:
12760 
12763 
12764  static const CFieldDescriptor * const
12765  s_apFieldDescriptorTable[];
12766 
12767  static const CTypeDescriptor
12768  s_typeDescriptor;
12769 
12770  void
12771  decodeFields (
12772  CDecoderStream * pDecoderStream);
12773 
12774  void
12775  assimilateSubParameters (
12776  CErrorDetails * pError);
12777 
12778  void
12779  encode (
12780  CEncoderStream * pEncoderStream) const;
12781 
12782 
12783  llrp_bool_t
12784  isAllowedIn (
12785  const CTypeDescriptor * pEnclosingElementType) const;
12786 
12787 
12788  static CElement *
12789  s_construct (void);
12790 
12791  static void
12792  s_decodeFields (
12793  CDecoderStream * pDecoderStream,
12794  CElement * pElement);
12796 
12797 
12798  protected:
12799  llrp_u16_t m_UserTagPopulationLimit;
12800 
12803  public:
12804  static const CFieldDescriptor
12805  s_fdUserTagPopulationLimit;
12807 
12809  inline llrp_u16_t
12811  {
12812  return m_UserTagPopulationLimit;
12813  }
12814 
12816  inline void
12818  llrp_u16_t value)
12819  {
12820  m_UserTagPopulationLimit = value;
12821  }
12822 
12823 
12824 
12825 };
12826 
12827 
12865 class CImpinjC1G2DirectionConfig : public CParameter
12866 {
12867  public:
12870 
12873 
12874  static const CFieldDescriptor * const
12875  s_apFieldDescriptorTable[];
12876 
12877  static const CTypeDescriptor
12878  s_typeDescriptor;
12879 
12880  void
12881  decodeFields (
12882  CDecoderStream * pDecoderStream);
12883 
12884  void
12885  assimilateSubParameters (
12886  CErrorDetails * pError);
12887 
12888  void
12889  encode (
12890  CEncoderStream * pEncoderStream) const;
12891 
12892 
12893  llrp_bool_t
12894  isAllowedIn (
12895  const CTypeDescriptor * pEnclosingElementType) const;
12896 
12897 
12898  static CElement *
12899  s_construct (void);
12900 
12901  static void
12902  s_decodeFields (
12903  CDecoderStream * pDecoderStream,
12904  CElement * pElement);
12906 
12907 
12908  protected:
12909  EImpinjDirectionRFMode m_eRFMode;
12910 
12913  public:
12914  static const CFieldDescriptor
12915  s_fdRFMode;
12917 
12919  inline EImpinjDirectionRFMode
12920  getRFMode (void)
12921  {
12922  return m_eRFMode;
12923  }
12924 
12926  inline void
12928  EImpinjDirectionRFMode value)
12929  {
12930  m_eRFMode = value;
12931  }
12932 
12933 
12934 
12935  protected:
12936  CImpinjTransmitPower * m_pImpinjTransmitPower;
12937 
12938  public:
12940  inline CImpinjTransmitPower *
12942  {
12943  return m_pImpinjTransmitPower;
12944  }
12945 
12947  EResultCode
12948  setImpinjTransmitPower (
12949  CImpinjTransmitPower * pValue);
12950 
12951 
12952  protected:
12953  std::list<CC1G2Filter *> m_listC1G2Filter;
12954 
12955  public:
12957  inline std::list<CC1G2Filter *>::iterator
12959  {
12960  return m_listC1G2Filter.begin();
12961  }
12962 
12964  inline std::list<CC1G2Filter *>::iterator
12966  {
12967  return m_listC1G2Filter.end();
12968  }
12969 
12971  inline void
12973  {
12974  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
12975  }
12976 
12978  inline int
12980  {
12981  return (int) (m_listC1G2Filter.size());
12982  }
12983 
12984  EResultCode
12986  addC1G2Filter (
12987  CC1G2Filter * pValue);
12988 
12989 
12990  protected:
12991  std::list<CParameter *> m_listCustom;
12992 
12993  public:
12995  inline std::list<CParameter *>::iterator
12997  {
12998  return m_listCustom.begin();
12999  }
13000 
13002  inline std::list<CParameter *>::iterator
13003  endCustom (void)
13004  {
13005  return m_listCustom.end();
13006  }
13007 
13009  inline void
13011  {
13012  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13013  }
13014 
13016  inline int
13018  {
13019  return (int) (m_listCustom.size());
13020  }
13021 
13022  EResultCode
13024  addCustom (
13025  CParameter * pValue);
13026 
13027 
13028 };
13029 
13030 
13063 class CImpinjExtendedTagInformation : public CParameter
13064 {
13065  public:
13068 
13071 
13072  static const CFieldDescriptor * const
13073  s_apFieldDescriptorTable[];
13074 
13075  static const CTypeDescriptor
13076  s_typeDescriptor;
13077 
13078  void
13079  decodeFields (
13080  CDecoderStream * pDecoderStream);
13081 
13082  void
13083  assimilateSubParameters (
13084  CErrorDetails * pError);
13085 
13086  void
13087  encode (
13088  CEncoderStream * pEncoderStream) const;
13089 
13090 
13091  llrp_bool_t
13092  isAllowedIn (
13093  const CTypeDescriptor * pEnclosingElementType) const;
13094 
13095 
13096  static CElement *
13097  s_construct (void);
13098 
13099  static void
13100  s_decodeFields (
13101  CDecoderStream * pDecoderStream,
13102  CElement * pElement);
13104 
13105 
13106 
13107  protected:
13108  std::list<CEPCData *> m_listEPCData;
13109 
13110  public:
13112  inline std::list<CEPCData *>::iterator
13114  {
13115  return m_listEPCData.begin();
13116  }
13117 
13119  inline std::list<CEPCData *>::iterator
13120  endEPCData (void)
13121  {
13122  return m_listEPCData.end();
13123  }
13124 
13126  inline void
13128  {
13129  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
13130  }
13131 
13133  inline int
13135  {
13136  return (int) (m_listEPCData.size());
13137  }
13138 
13139  EResultCode
13141  addEPCData (
13142  CEPCData * pValue);
13143 
13144 
13145  protected:
13146  CImpinjLocationReportData * m_pImpinjLocationReportData;
13147 
13148  public:
13150  inline CImpinjLocationReportData *
13152  {
13153  return m_pImpinjLocationReportData;
13154  }
13155 
13157  EResultCode
13158  setImpinjLocationReportData (
13159  CImpinjLocationReportData * pValue);
13160 
13161 
13162  protected:
13163  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
13164 
13165  public:
13169  {
13170  return m_pImpinjDirectionReportData;
13171  }
13172 
13174  EResultCode
13175  setImpinjDirectionReportData (
13176  CImpinjDirectionReportData * pValue);
13177 
13178 
13179  protected:
13180  std::list<CParameter *> m_listCustom;
13181 
13182  public:
13184  inline std::list<CParameter *>::iterator
13186  {
13187  return m_listCustom.begin();
13188  }
13189 
13191  inline std::list<CParameter *>::iterator
13192  endCustom (void)
13193  {
13194  return m_listCustom.end();
13195  }
13196 
13198  inline void
13200  {
13201  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13202  }
13203 
13205  inline int
13207  {
13208  return (int) (m_listCustom.size());
13209  }
13210 
13211  EResultCode
13213  addCustom (
13214  CParameter * pValue);
13215 
13216 
13217 };
13218 
13219 
13266 class CImpinjDirectionReporting : public CParameter
13267 {
13268  public:
13270  ~CImpinjDirectionReporting (void);
13271 
13274 
13275  static const CFieldDescriptor * const
13276  s_apFieldDescriptorTable[];
13277 
13278  static const CTypeDescriptor
13279  s_typeDescriptor;
13280 
13281  void
13282  decodeFields (
13283  CDecoderStream * pDecoderStream);
13284 
13285  void
13286  assimilateSubParameters (
13287  CErrorDetails * pError);
13288 
13289  void
13290  encode (
13291  CEncoderStream * pEncoderStream) const;
13292 
13293 
13294  llrp_bool_t
13295  isAllowedIn (
13296  const CTypeDescriptor * pEnclosingElementType) const;
13297 
13298 
13299  static CElement *
13300  s_construct (void);
13301 
13302  static void
13303  s_decodeFields (
13304  CDecoderStream * pDecoderStream,
13305  CElement * pElement);
13307 
13308 
13309  protected:
13310  llrp_u1_t m_EnableUpdateReport;
13311 
13314  public:
13315  static const CFieldDescriptor
13316  s_fdEnableUpdateReport;
13318 
13320  inline llrp_u1_t
13322  {
13323  return m_EnableUpdateReport;
13324  }
13325 
13327  inline void
13329  llrp_u1_t value)
13330  {
13331  m_EnableUpdateReport = value;
13332  }
13333 
13334 
13335  protected:
13336  llrp_u1_t m_EnableEntryReport;
13337 
13340  public:
13341  static const CFieldDescriptor
13342  s_fdEnableEntryReport;
13344 
13346  inline llrp_u1_t
13348  {
13349  return m_EnableEntryReport;
13350  }
13351 
13353  inline void
13355  llrp_u1_t value)
13356  {
13357  m_EnableEntryReport = value;
13358  }
13359 
13360 
13361  protected:
13362  llrp_u1_t m_EnableExitReport;
13363 
13366  public:
13367  static const CFieldDescriptor
13368  s_fdEnableExitReport;
13370 
13372  inline llrp_u1_t
13374  {
13375  return m_EnableExitReport;
13376  }
13377 
13379  inline void
13381  llrp_u1_t value)
13382  {
13383  m_EnableExitReport = value;
13384  }
13385 
13386 
13387  protected:
13388  llrp_u1_t m_EnableDiagnosticReport;
13389 
13392  public:
13393  static const CFieldDescriptor
13394  s_fdEnableDiagnosticReport;
13396 
13398  inline llrp_u1_t
13400  {
13401  return m_EnableDiagnosticReport;
13402  }
13403 
13405  inline void
13407  llrp_u1_t value)
13408  {
13409  m_EnableDiagnosticReport = value;
13410  }
13411 
13412 
13413  protected:
13414  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
13415 
13418  public:
13419  static const CFieldDescriptor
13420  s_fdDiagnosticReportLevel;
13422 
13424  inline EImpinjDirectionDiagnosticReportLevel
13426  {
13427  return m_eDiagnosticReportLevel;
13428  }
13429 
13431  inline void
13433  EImpinjDirectionDiagnosticReportLevel value)
13434  {
13435  m_eDiagnosticReportLevel = value;
13436  }
13437 
13438 
13439 
13440  protected:
13441  std::list<CParameter *> m_listCustom;
13442 
13443  public:
13445  inline std::list<CParameter *>::iterator
13447  {
13448  return m_listCustom.begin();
13449  }
13450 
13452  inline std::list<CParameter *>::iterator
13453  endCustom (void)
13454  {
13455  return m_listCustom.end();
13456  }
13457 
13459  inline void
13461  {
13462  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13463  }
13464 
13466  inline int
13468  {
13469  return (int) (m_listCustom.size());
13470  }
13471 
13472  EResultCode
13474  addCustom (
13475  CParameter * pValue);
13476 
13477 
13478 };
13479 
13480 
13528 class CImpinjDirectionReportData : public CParameter
13529 {
13530  public:
13533 
13536 
13537  static const CFieldDescriptor * const
13538  s_apFieldDescriptorTable[];
13539 
13540  static const CTypeDescriptor
13541  s_typeDescriptor;
13542 
13543  void
13544  decodeFields (
13545  CDecoderStream * pDecoderStream);
13546 
13547  void
13548  assimilateSubParameters (
13549  CErrorDetails * pError);
13550 
13551  void
13552  encode (
13553  CEncoderStream * pEncoderStream) const;
13554 
13555 
13556  llrp_bool_t
13557  isAllowedIn (
13558  const CTypeDescriptor * pEnclosingElementType) const;
13559 
13560 
13561  static CElement *
13562  s_construct (void);
13563 
13564  static void
13565  s_decodeFields (
13566  CDecoderStream * pDecoderStream,
13567  CElement * pElement);
13569 
13570 
13571  protected:
13572  EImpinjDirectionReportType m_eType;
13573 
13576  public:
13577  static const CFieldDescriptor
13578  s_fdType;
13580 
13582  inline EImpinjDirectionReportType
13583  getType (void)
13584  {
13585  return m_eType;
13586  }
13587 
13589  inline void
13591  EImpinjDirectionReportType value)
13592  {
13593  m_eType = value;
13594  }
13595 
13596 
13597  protected:
13598  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13599 
13602  public:
13603  static const CFieldDescriptor
13604  s_fdTagPopulationStatus;
13606 
13608  inline EImpinjDirectionTagPopulationStatus
13610  {
13611  return m_eTagPopulationStatus;
13612  }
13613 
13615  inline void
13617  EImpinjDirectionTagPopulationStatus value)
13618  {
13619  m_eTagPopulationStatus = value;
13620  }
13621 
13622 
13623  protected:
13624  llrp_u8_t m_FirstSeenSectorID;
13625 
13628  public:
13629  static const CFieldDescriptor
13630  s_fdFirstSeenSectorID;
13632 
13634  inline llrp_u8_t
13636  {
13637  return m_FirstSeenSectorID;
13638  }
13639 
13641  inline void
13643  llrp_u8_t value)
13644  {
13645  m_FirstSeenSectorID = value;
13646  }
13647 
13648 
13649  protected:
13650  llrp_u64_t m_FirstSeenTimestampUTC;
13651 
13654  public:
13655  static const CFieldDescriptor
13656  s_fdFirstSeenTimestampUTC;
13658 
13660  inline llrp_u64_t
13662  {
13663  return m_FirstSeenTimestampUTC;
13664  }
13665 
13667  inline void
13669  llrp_u64_t value)
13670  {
13671  m_FirstSeenTimestampUTC = value;
13672  }
13673 
13674 
13675  protected:
13676  llrp_u8_t m_LastSeenSectorID;
13677 
13680  public:
13681  static const CFieldDescriptor
13682  s_fdLastSeenSectorID;
13684 
13686  inline llrp_u8_t
13688  {
13689  return m_LastSeenSectorID;
13690  }
13691 
13693  inline void
13695  llrp_u8_t value)
13696  {
13697  m_LastSeenSectorID = value;
13698  }
13699 
13700 
13701  protected:
13702  llrp_u64_t m_LastSeenTimestampUTC;
13703 
13706  public:
13707  static const CFieldDescriptor
13708  s_fdLastSeenTimestampUTC;
13710 
13712  inline llrp_u64_t
13714  {
13715  return m_LastSeenTimestampUTC;
13716  }
13717 
13719  inline void
13721  llrp_u64_t value)
13722  {
13723  m_LastSeenTimestampUTC = value;
13724  }
13725 
13726 
13727 
13728  protected:
13729  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13730 
13731  public:
13735  {
13736  return m_pImpinjDirectionDiagnosticData;
13737  }
13738 
13740  EResultCode
13741  setImpinjDirectionDiagnosticData (
13743 
13744 
13745  protected:
13746  std::list<CParameter *> m_listCustom;
13747 
13748  public:
13750  inline std::list<CParameter *>::iterator
13752  {
13753  return m_listCustom.begin();
13754  }
13755 
13757  inline std::list<CParameter *>::iterator
13758  endCustom (void)
13759  {
13760  return m_listCustom.end();
13761  }
13762 
13764  inline void
13766  {
13767  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13768  }
13769 
13771  inline int
13773  {
13774  return (int) (m_listCustom.size());
13775  }
13776 
13777  EResultCode
13779  addCustom (
13780  CParameter * pValue);
13781 
13782 
13783 };
13784 
13785 
13808 class CImpinjDirectionDiagnosticData : public CParameter
13809 {
13810  public:
13813 
13816 
13817  static const CFieldDescriptor * const
13818  s_apFieldDescriptorTable[];
13819 
13820  static const CTypeDescriptor
13821  s_typeDescriptor;
13822 
13823  void
13824  decodeFields (
13825  CDecoderStream * pDecoderStream);
13826 
13827  void
13828  assimilateSubParameters (
13829  CErrorDetails * pError);
13830 
13831  void
13832  encode (
13833  CEncoderStream * pEncoderStream) const;
13834 
13835 
13836  llrp_bool_t
13837  isAllowedIn (
13838  const CTypeDescriptor * pEnclosingElementType) const;
13839 
13840 
13841  static CElement *
13842  s_construct (void);
13843 
13844  static void
13845  s_decodeFields (
13846  CDecoderStream * pDecoderStream,
13847  CElement * pElement);
13849 
13850 
13851  protected:
13852  llrp_u32v_t m_Metric;
13853 
13856  public:
13857  static const CFieldDescriptor
13858  s_fdMetric;
13860 
13862  inline llrp_u32v_t
13863  getMetric (void)
13864  {
13865  return m_Metric;
13866  }
13867 
13869  inline void
13871  llrp_u32v_t value)
13872  {
13873  m_Metric = value;
13874  }
13875 
13876 
13877 
13878 };
13879 
13880 
13905 class CImpinjxArrayDirectionCapabilities : public CParameter
13906 {
13907  public:
13910 
13913 
13914  static const CFieldDescriptor * const
13915  s_apFieldDescriptorTable[];
13916 
13917  static const CTypeDescriptor
13918  s_typeDescriptor;
13919 
13920  void
13921  decodeFields (
13922  CDecoderStream * pDecoderStream);
13923 
13924  void
13925  assimilateSubParameters (
13926  CErrorDetails * pError);
13927 
13928  void
13929  encode (
13930  CEncoderStream * pEncoderStream) const;
13931 
13932 
13933  llrp_bool_t
13934  isAllowedIn (
13935  const CTypeDescriptor * pEnclosingElementType) const;
13936 
13937 
13938  static CElement *
13939  s_construct (void);
13940 
13941  static void
13942  s_decodeFields (
13943  CDecoderStream * pDecoderStream,
13944  CElement * pElement);
13946 
13947 
13948  protected:
13949  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13950 
13953  public:
13954  static const CFieldDescriptor
13955  s_fdSystemTagPopulationLimitHighSensitivity;
13957 
13959  inline llrp_u16_t
13961  {
13962  return m_SystemTagPopulationLimitHighSensitivity;
13963  }
13964 
13966  inline void
13968  llrp_u16_t value)
13969  {
13970  m_SystemTagPopulationLimitHighSensitivity = value;
13971  }
13972 
13973 
13974  protected:
13975  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
13976 
13979  public:
13980  static const CFieldDescriptor
13981  s_fdSystemTagPopulationLimitHighPerformance;
13983 
13985  inline llrp_u16_t
13987  {
13988  return m_SystemTagPopulationLimitHighPerformance;
13989  }
13990 
13992  inline void
13994  llrp_u16_t value)
13995  {
13996  m_SystemTagPopulationLimitHighPerformance = value;
13997  }
13998 
13999 
14000 
14001  protected:
14002  std::list<CParameter *> m_listCustom;
14003 
14004  public:
14006  inline std::list<CParameter *>::iterator
14008  {
14009  return m_listCustom.begin();
14010  }
14011 
14013  inline std::list<CParameter *>::iterator
14014  endCustom (void)
14015  {
14016  return m_listCustom.end();
14017  }
14018 
14020  inline void
14022  {
14023  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14024  }
14025 
14027  inline int
14029  {
14030  return (int) (m_listCustom.size());
14031  }
14032 
14033  EResultCode
14035  addCustom (
14036  CParameter * pValue);
14037 
14038 
14039 };
14040 
14041 
14067 class CImpinjIntelligentAntennaManagement : public CParameter
14068 {
14069  public:
14072 
14075 
14076  static const CFieldDescriptor * const
14077  s_apFieldDescriptorTable[];
14078 
14079  static const CTypeDescriptor
14080  s_typeDescriptor;
14081 
14082  void
14083  decodeFields (
14084  CDecoderStream * pDecoderStream);
14085 
14086  void
14087  assimilateSubParameters (
14088  CErrorDetails * pError);
14089 
14090  void
14091  encode (
14092  CEncoderStream * pEncoderStream) const;
14093 
14094 
14095  llrp_bool_t
14096  isAllowedIn (
14097  const CTypeDescriptor * pEnclosingElementType) const;
14098 
14099 
14100  static CElement *
14101  s_construct (void);
14102 
14103  static void
14104  s_decodeFields (
14105  CDecoderStream * pDecoderStream,
14106  CElement * pElement);
14108 
14109 
14110  protected:
14111  EImpinjIntelligentAntennaMode m_eManagementEnabled;
14112 
14115  public:
14116  static const CFieldDescriptor
14117  s_fdManagementEnabled;
14119 
14121  inline EImpinjIntelligentAntennaMode
14123  {
14124  return m_eManagementEnabled;
14125  }
14126 
14128  inline void
14130  EImpinjIntelligentAntennaMode value)
14131  {
14132  m_eManagementEnabled = value;
14133  }
14134 
14135 
14136 
14137  protected:
14138  std::list<CParameter *> m_listCustom;
14139 
14140  public:
14142  inline std::list<CParameter *>::iterator
14144  {
14145  return m_listCustom.begin();
14146  }
14147 
14149  inline std::list<CParameter *>::iterator
14150  endCustom (void)
14151  {
14152  return m_listCustom.end();
14153  }
14154 
14156  inline void
14158  {
14159  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14160  }
14161 
14163  inline int
14165  {
14166  return (int) (m_listCustom.size());
14167  }
14168 
14169  EResultCode
14171  addCustom (
14172  CParameter * pValue);
14173 
14174 
14175 };
14176 
14177 
14204 class CImpinjTransmitPower : public CParameter
14205 {
14206  public:
14207  CImpinjTransmitPower (void);
14208  ~CImpinjTransmitPower (void);
14209 
14212 
14213  static const CFieldDescriptor * const
14214  s_apFieldDescriptorTable[];
14215 
14216  static const CTypeDescriptor
14217  s_typeDescriptor;
14218 
14219  void
14220  decodeFields (
14221  CDecoderStream * pDecoderStream);
14222 
14223  void
14224  assimilateSubParameters (
14225  CErrorDetails * pError);
14226 
14227  void
14228  encode (
14229  CEncoderStream * pEncoderStream) const;
14230 
14231 
14232  llrp_bool_t
14233  isAllowedIn (
14234  const CTypeDescriptor * pEnclosingElementType) const;
14235 
14236 
14237  static CElement *
14238  s_construct (void);
14239 
14240  static void
14241  s_decodeFields (
14242  CDecoderStream * pDecoderStream,
14243  CElement * pElement);
14245 
14246 
14247  protected:
14248  llrp_u16_t m_TransmitPower;
14249 
14252  public:
14253  static const CFieldDescriptor
14254  s_fdTransmitPower;
14256 
14258  inline llrp_u16_t
14260  {
14261  return m_TransmitPower;
14262  }
14263 
14265  inline void
14267  llrp_u16_t value)
14268  {
14269  m_TransmitPower = value;
14270  }
14271 
14272 
14273 
14274  protected:
14275  std::list<CParameter *> m_listCustom;
14276 
14277  public:
14279  inline std::list<CParameter *>::iterator
14281  {
14282  return m_listCustom.begin();
14283  }
14284 
14286  inline std::list<CParameter *>::iterator
14287  endCustom (void)
14288  {
14289  return m_listCustom.end();
14290  }
14291 
14293  inline void
14295  {
14296  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14297  }
14298 
14300  inline int
14302  {
14303  return (int) (m_listCustom.size());
14304  }
14305 
14306  EResultCode
14308  addCustom (
14309  CParameter * pValue);
14310 
14311 
14312 };
14313 
14314 
14341 class CImpinjPolarizationControl : public CParameter
14342 {
14343  public:
14346 
14349 
14350  static const CFieldDescriptor * const
14351  s_apFieldDescriptorTable[];
14352 
14353  static const CTypeDescriptor
14354  s_typeDescriptor;
14355 
14356  void
14357  decodeFields (
14358  CDecoderStream * pDecoderStream);
14359 
14360  void
14361  assimilateSubParameters (
14362  CErrorDetails * pError);
14363 
14364  void
14365  encode (
14366  CEncoderStream * pEncoderStream) const;
14367 
14368 
14369  llrp_bool_t
14370  isAllowedIn (
14371  const CTypeDescriptor * pEnclosingElementType) const;
14372 
14373 
14374  static CElement *
14375  s_construct (void);
14376 
14377  static void
14378  s_decodeFields (
14379  CDecoderStream * pDecoderStream,
14380  CElement * pElement);
14382 
14383 
14384  protected:
14385  llrp_u1_t m_PolarizationControlEnabled;
14386 
14389  public:
14390  static const CFieldDescriptor
14391  s_fdPolarizationControlEnabled;
14393 
14395  inline llrp_u1_t
14397  {
14398  return m_PolarizationControlEnabled;
14399  }
14400 
14402  inline void
14404  llrp_u1_t value)
14405  {
14406  m_PolarizationControlEnabled = value;
14407  }
14408 
14409 
14410 
14411  protected:
14412  std::list<CParameter *> m_listCustom;
14413 
14414  public:
14416  inline std::list<CParameter *>::iterator
14418  {
14419  return m_listCustom.begin();
14420  }
14421 
14423  inline std::list<CParameter *>::iterator
14424  endCustom (void)
14425  {
14426  return m_listCustom.end();
14427  }
14428 
14430  inline void
14432  {
14433  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14434  }
14435 
14437  inline int
14439  {
14440  return (int) (m_listCustom.size());
14441  }
14442 
14443  EResultCode
14445  addCustom (
14446  CParameter * pValue);
14447 
14448 
14449 };
14450 
14451 
14476 class CImpinjAntennaCapabilities : public CParameter
14477 {
14478  public:
14481 
14484 
14485  static const CFieldDescriptor * const
14486  s_apFieldDescriptorTable[];
14487 
14488  static const CTypeDescriptor
14489  s_typeDescriptor;
14490 
14491  void
14492  decodeFields (
14493  CDecoderStream * pDecoderStream);
14494 
14495  void
14496  assimilateSubParameters (
14497  CErrorDetails * pError);
14498 
14499  void
14500  encode (
14501  CEncoderStream * pEncoderStream) const;
14502 
14503 
14504  llrp_bool_t
14505  isAllowedIn (
14506  const CTypeDescriptor * pEnclosingElementType) const;
14507 
14508 
14509  static CElement *
14510  s_construct (void);
14511 
14512  static void
14513  s_decodeFields (
14514  CDecoderStream * pDecoderStream,
14515  CElement * pElement);
14517 
14518 
14519 
14520  protected:
14521  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
14522 
14523  public:
14525  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14527  {
14528  return m_listImpinjAntennaPolarizationCapability.begin();
14529  }
14530 
14532  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14534  {
14535  return m_listImpinjAntennaPolarizationCapability.end();
14536  }
14537 
14539  inline void
14541  {
14542  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
14543  }
14544 
14546  inline int
14548  {
14549  return (int) (m_listImpinjAntennaPolarizationCapability.size());
14550  }
14551 
14552  EResultCode
14554  addImpinjAntennaPolarizationCapability (
14556 
14557 
14558  protected:
14559  std::list<CParameter *> m_listCustom;
14560 
14561  public:
14563  inline std::list<CParameter *>::iterator
14565  {
14566  return m_listCustom.begin();
14567  }
14568 
14570  inline std::list<CParameter *>::iterator
14571  endCustom (void)
14572  {
14573  return m_listCustom.end();
14574  }
14575 
14577  inline void
14579  {
14580  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14581  }
14582 
14584  inline int
14586  {
14587  return (int) (m_listCustom.size());
14588  }
14589 
14590  EResultCode
14592  addCustom (
14593  CParameter * pValue);
14594 
14595 
14596 };
14597 
14598 
14623 class CImpinjAntennaPolarizationCapability : public CParameter
14624 {
14625  public:
14628 
14631 
14632  static const CFieldDescriptor * const
14633  s_apFieldDescriptorTable[];
14634 
14635  static const CTypeDescriptor
14636  s_typeDescriptor;
14637 
14638  void
14639  decodeFields (
14640  CDecoderStream * pDecoderStream);
14641 
14642  void
14643  assimilateSubParameters (
14644  CErrorDetails * pError);
14645 
14646  void
14647  encode (
14648  CEncoderStream * pEncoderStream) const;
14649 
14650 
14651  llrp_bool_t
14652  isAllowedIn (
14653  const CTypeDescriptor * pEnclosingElementType) const;
14654 
14655 
14656  static CElement *
14657  s_construct (void);
14658 
14659  static void
14660  s_decodeFields (
14661  CDecoderStream * pDecoderStream,
14662  CElement * pElement);
14664 
14665 
14666  protected:
14667  EImpinjAntennaPolarizationType m_eType;
14668 
14671  public:
14672  static const CFieldDescriptor
14673  s_fdType;
14675 
14677  inline EImpinjAntennaPolarizationType
14678  getType (void)
14679  {
14680  return m_eType;
14681  }
14682 
14684  inline void
14686  EImpinjAntennaPolarizationType value)
14687  {
14688  m_eType = value;
14689  }
14690 
14691 
14692  protected:
14693  llrp_u16_t m_AntennaIDOffset;
14694 
14697  public:
14698  static const CFieldDescriptor
14699  s_fdAntennaIDOffset;
14701 
14703  inline llrp_u16_t
14705  {
14706  return m_AntennaIDOffset;
14707  }
14708 
14710  inline void
14712  llrp_u16_t value)
14713  {
14714  m_AntennaIDOffset = value;
14715  }
14716 
14717 
14718 
14719  protected:
14720  std::list<CParameter *> m_listCustom;
14721 
14722  public:
14724  inline std::list<CParameter *>::iterator
14726  {
14727  return m_listCustom.begin();
14728  }
14729 
14731  inline std::list<CParameter *>::iterator
14732  endCustom (void)
14733  {
14734  return m_listCustom.end();
14735  }
14736 
14738  inline void
14740  {
14741  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14742  }
14743 
14745  inline int
14747  {
14748  return (int) (m_listCustom.size());
14749  }
14750 
14751  EResultCode
14753  addCustom (
14754  CParameter * pValue);
14755 
14756 
14757 };
14758 
14759 
14783 class CImpinjDisabledAntennas : public CParameter
14784 {
14785  public:
14786  CImpinjDisabledAntennas (void);
14787  ~CImpinjDisabledAntennas (void);
14788 
14791 
14792  static const CFieldDescriptor * const
14793  s_apFieldDescriptorTable[];
14794 
14795  static const CTypeDescriptor
14796  s_typeDescriptor;
14797 
14798  void
14799  decodeFields (
14800  CDecoderStream * pDecoderStream);
14801 
14802  void
14803  assimilateSubParameters (
14804  CErrorDetails * pError);
14805 
14806  void
14807  encode (
14808  CEncoderStream * pEncoderStream) const;
14809 
14810 
14811  llrp_bool_t
14812  isAllowedIn (
14813  const CTypeDescriptor * pEnclosingElementType) const;
14814 
14815 
14816  static CElement *
14817  s_construct (void);
14818 
14819  static void
14820  s_decodeFields (
14821  CDecoderStream * pDecoderStream,
14822  CElement * pElement);
14824 
14825 
14826  protected:
14827  llrp_u16v_t m_AntennaIDs;
14828 
14831  public:
14832  static const CFieldDescriptor
14833  s_fdAntennaIDs;
14835 
14837  inline llrp_u16v_t
14839  {
14840  return m_AntennaIDs;
14841  }
14842 
14844  inline void
14846  llrp_u16v_t value)
14847  {
14848  m_AntennaIDs = value;
14849  }
14850 
14851 
14852 
14853  protected:
14854  std::list<CParameter *> m_listCustom;
14855 
14856  public:
14858  inline std::list<CParameter *>::iterator
14860  {
14861  return m_listCustom.begin();
14862  }
14863 
14865  inline std::list<CParameter *>::iterator
14866  endCustom (void)
14867  {
14868  return m_listCustom.end();
14869  }
14870 
14872  inline void
14874  {
14875  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14876  }
14877 
14879  inline int
14881  {
14882  return (int) (m_listCustom.size());
14883  }
14884 
14885  EResultCode
14887  addCustom (
14888  CParameter * pValue);
14889 
14890 
14891 };
14892 
14893 
14918 class CImpinjTIDParity : public CParameter
14919 {
14920  public:
14921  CImpinjTIDParity (void);
14922  ~CImpinjTIDParity (void);
14923 
14926 
14927  static const CFieldDescriptor * const
14928  s_apFieldDescriptorTable[];
14929 
14930  static const CTypeDescriptor
14931  s_typeDescriptor;
14932 
14933  void
14934  decodeFields (
14935  CDecoderStream * pDecoderStream);
14936 
14937  void
14938  assimilateSubParameters (
14939  CErrorDetails * pError);
14940 
14941  void
14942  encode (
14943  CEncoderStream * pEncoderStream) const;
14944 
14945 
14946  llrp_bool_t
14947  isAllowedIn (
14948  const CTypeDescriptor * pEnclosingElementType) const;
14949 
14950 
14951  static CElement *
14952  s_construct (void);
14953 
14954  static void
14955  s_decodeFields (
14956  CDecoderStream * pDecoderStream,
14957  CElement * pElement);
14959 
14960 
14961  protected:
14962  llrp_u1_t m_ParityError;
14963 
14966  public:
14967  static const CFieldDescriptor
14968  s_fdParityError;
14970 
14972  inline llrp_u1_t
14974  {
14975  return m_ParityError;
14976  }
14977 
14979  inline void
14981  llrp_u1_t value)
14982  {
14983  m_ParityError = value;
14984  }
14985 
14986 
14987 
14988  protected:
14989  std::list<CParameter *> m_listCustom;
14990 
14991  public:
14993  inline std::list<CParameter *>::iterator
14995  {
14996  return m_listCustom.begin();
14997  }
14998 
15000  inline std::list<CParameter *>::iterator
15001  endCustom (void)
15002  {
15003  return m_listCustom.end();
15004  }
15005 
15007  inline void
15009  {
15010  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15011  }
15012 
15014  inline int
15016  {
15017  return (int) (m_listCustom.size());
15018  }
15019 
15020  EResultCode
15022  addCustom (
15023  CParameter * pValue);
15024 
15025 
15026 };
15027 
15028 
15059 class CImpinjMarginRead : public CParameter
15060 {
15061  public:
15062  CImpinjMarginRead (void);
15063  ~CImpinjMarginRead (void);
15064 
15067 
15068  static const CFieldDescriptor * const
15069  s_apFieldDescriptorTable[];
15070 
15071  static const CTypeDescriptor
15072  s_typeDescriptor;
15073 
15074  void
15075  decodeFields (
15076  CDecoderStream * pDecoderStream);
15077 
15078  void
15079  assimilateSubParameters (
15080  CErrorDetails * pError);
15081 
15082  void
15083  encode (
15084  CEncoderStream * pEncoderStream) const;
15085 
15086 
15087  llrp_bool_t
15088  isAllowedIn (
15089  const CTypeDescriptor * pEnclosingElementType) const;
15090 
15091 
15092  static CElement *
15093  s_construct (void);
15094 
15095  static void
15096  s_decodeFields (
15097  CDecoderStream * pDecoderStream,
15098  CElement * pElement);
15100 
15101 
15102  protected:
15103  llrp_u16_t m_OpSpecID;
15104 
15107  public:
15108  static const CFieldDescriptor
15109  s_fdOpSpecID;
15111 
15113  inline llrp_u16_t
15115  {
15116  return m_OpSpecID;
15117  }
15118 
15120  inline void
15122  llrp_u16_t value)
15123  {
15124  m_OpSpecID = value;
15125  }
15126 
15127 
15128  protected:
15129  llrp_u32_t m_AccessPassword;
15130 
15133  public:
15134  static const CFieldDescriptor
15135  s_fdAccessPassword;
15137 
15139  inline llrp_u32_t
15141  {
15142  return m_AccessPassword;
15143  }
15144 
15146  inline void
15148  llrp_u32_t value)
15149  {
15150  m_AccessPassword = value;
15151  }
15152 
15153 
15154  protected:
15155  llrp_u2_t m_MB;
15156 
15159  public:
15160  static const CFieldDescriptor
15161  s_fdMB;
15163 
15165  inline llrp_u2_t
15166  getMB (void)
15167  {
15168  return m_MB;
15169  }
15170 
15172  inline void
15174  llrp_u2_t value)
15175  {
15176  m_MB = value;
15177  }
15178 
15179 
15180  protected:
15181  llrp_u16_t m_BitPointer;
15182 
15185  public:
15186  static const CFieldDescriptor
15187  s_fdBitPointer;
15189 
15191  inline llrp_u16_t
15193  {
15194  return m_BitPointer;
15195  }
15196 
15198  inline void
15200  llrp_u16_t value)
15201  {
15202  m_BitPointer = value;
15203  }
15204 
15205 
15206  protected:
15207  llrp_u8_t m_BitLength;
15208 
15211  public:
15212  static const CFieldDescriptor
15213  s_fdBitLength;
15215 
15217  inline llrp_u8_t
15219  {
15220  return m_BitLength;
15221  }
15222 
15224  inline void
15226  llrp_u8_t value)
15227  {
15228  m_BitLength = value;
15229  }
15230 
15231 
15232  protected:
15233  llrp_u16v_t m_Mask;
15234 
15237  public:
15238  static const CFieldDescriptor
15239  s_fdMask;
15241 
15243  inline llrp_u16v_t
15244  getMask (void)
15245  {
15246  return m_Mask;
15247  }
15248 
15250  inline void
15252  llrp_u16v_t value)
15253  {
15254  m_Mask = value;
15255  }
15256 
15257 
15258 
15259  protected:
15260  std::list<CParameter *> m_listCustom;
15261 
15262  public:
15264  inline std::list<CParameter *>::iterator
15266  {
15267  return m_listCustom.begin();
15268  }
15269 
15271  inline std::list<CParameter *>::iterator
15272  endCustom (void)
15273  {
15274  return m_listCustom.end();
15275  }
15276 
15278  inline void
15280  {
15281  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15282  }
15283 
15285  inline int
15287  {
15288  return (int) (m_listCustom.size());
15289  }
15290 
15291  EResultCode
15293  addCustom (
15294  CParameter * pValue);
15295 
15296 
15297 };
15298 
15299 
15325 class CImpinjMarginReadOpSpecResult : public CParameter
15326 {
15327  public:
15330 
15333 
15334  static const CFieldDescriptor * const
15335  s_apFieldDescriptorTable[];
15336 
15337  static const CTypeDescriptor
15338  s_typeDescriptor;
15339 
15340  void
15341  decodeFields (
15342  CDecoderStream * pDecoderStream);
15343 
15344  void
15345  assimilateSubParameters (
15346  CErrorDetails * pError);
15347 
15348  void
15349  encode (
15350  CEncoderStream * pEncoderStream) const;
15351 
15352 
15353  llrp_bool_t
15354  isAllowedIn (
15355  const CTypeDescriptor * pEnclosingElementType) const;
15356 
15357 
15358  static CElement *
15359  s_construct (void);
15360 
15361  static void
15362  s_decodeFields (
15363  CDecoderStream * pDecoderStream,
15364  CElement * pElement);
15366 
15367 
15368  protected:
15369  EImpinjMarginReadResultType m_eResult;
15370 
15373  public:
15374  static const CFieldDescriptor
15375  s_fdResult;
15377 
15379  inline EImpinjMarginReadResultType
15380  getResult (void)
15381  {
15382  return m_eResult;
15383  }
15384 
15386  inline void
15388  EImpinjMarginReadResultType value)
15389  {
15390  m_eResult = value;
15391  }
15392 
15393 
15394  protected:
15395  llrp_u16_t m_OpSpecID;
15396 
15399  public:
15400  static const CFieldDescriptor
15401  s_fdOpSpecID;
15403 
15405  inline llrp_u16_t
15407  {
15408  return m_OpSpecID;
15409  }
15410 
15412  inline void
15414  llrp_u16_t value)
15415  {
15416  m_OpSpecID = value;
15417  }
15418 
15419 
15420 
15421  protected:
15422  std::list<CParameter *> m_listCustom;
15423 
15424  public:
15426  inline std::list<CParameter *>::iterator
15428  {
15429  return m_listCustom.begin();
15430  }
15431 
15433  inline std::list<CParameter *>::iterator
15434  endCustom (void)
15435  {
15436  return m_listCustom.end();
15437  }
15438 
15440  inline void
15442  {
15443  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15444  }
15445 
15447  inline int
15449  {
15450  return (int) (m_listCustom.size());
15451  }
15452 
15453  EResultCode
15455  addCustom (
15456  CParameter * pValue);
15457 
15458 
15459 };
15460 
15461 
15486 class CImpinjBLEVersion : public CParameter
15487 {
15488  public:
15489  CImpinjBLEVersion (void);
15490  ~CImpinjBLEVersion (void);
15491 
15494 
15495  static const CFieldDescriptor * const
15496  s_apFieldDescriptorTable[];
15497 
15498  static const CTypeDescriptor
15499  s_typeDescriptor;
15500 
15501  void
15502  decodeFields (
15503  CDecoderStream * pDecoderStream);
15504 
15505  void
15506  assimilateSubParameters (
15507  CErrorDetails * pError);
15508 
15509  void
15510  encode (
15511  CEncoderStream * pEncoderStream) const;
15512 
15513 
15514  llrp_bool_t
15515  isAllowedIn (
15516  const CTypeDescriptor * pEnclosingElementType) const;
15517 
15518 
15519  static CElement *
15520  s_construct (void);
15521 
15522  static void
15523  s_decodeFields (
15524  CDecoderStream * pDecoderStream,
15525  CElement * pElement);
15527 
15528 
15529  protected:
15530  llrp_utf8v_t m_FirmwareVersion;
15531 
15534  public:
15535  static const CFieldDescriptor
15536  s_fdFirmwareVersion;
15538 
15540  inline llrp_utf8v_t
15542  {
15543  return m_FirmwareVersion;
15544  }
15545 
15547  inline void
15549  llrp_utf8v_t value)
15550  {
15551  m_FirmwareVersion = value;
15552  }
15553 
15554 
15555 
15556  protected:
15557  std::list<CParameter *> m_listCustom;
15558 
15559  public:
15561  inline std::list<CParameter *>::iterator
15563  {
15564  return m_listCustom.begin();
15565  }
15566 
15568  inline std::list<CParameter *>::iterator
15569  endCustom (void)
15570  {
15571  return m_listCustom.end();
15572  }
15573 
15575  inline void
15577  {
15578  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15579  }
15580 
15582  inline int
15584  {
15585  return (int) (m_listCustom.size());
15586  }
15587 
15588  EResultCode
15590  addCustom (
15591  CParameter * pValue);
15592 
15593 
15594 };
15595 
15596 
15620 class CImpinjLocationAlgorithmControl : public CParameter
15621 {
15622  public:
15625 
15628 
15629  static const CFieldDescriptor * const
15630  s_apFieldDescriptorTable[];
15631 
15632  static const CTypeDescriptor
15633  s_typeDescriptor;
15634 
15635  void
15636  decodeFields (
15637  CDecoderStream * pDecoderStream);
15638 
15639  void
15640  assimilateSubParameters (
15641  CErrorDetails * pError);
15642 
15643  void
15644  encode (
15645  CEncoderStream * pEncoderStream) const;
15646 
15647 
15648  llrp_bool_t
15649  isAllowedIn (
15650  const CTypeDescriptor * pEnclosingElementType) const;
15651 
15652 
15653  static CElement *
15654  s_construct (void);
15655 
15656  static void
15657  s_decodeFields (
15658  CDecoderStream * pDecoderStream,
15659  CElement * pElement);
15661 
15662 
15663  protected:
15664  llrp_u32v_t m_ControlData;
15665 
15668  public:
15669  static const CFieldDescriptor
15670  s_fdControlData;
15672 
15674  inline llrp_u32v_t
15676  {
15677  return m_ControlData;
15678  }
15679 
15681  inline void
15683  llrp_u32v_t value)
15684  {
15685  m_ControlData = value;
15686  }
15687 
15688 
15689 
15690  protected:
15691  std::list<CParameter *> m_listCustom;
15692 
15693  public:
15695  inline std::list<CParameter *>::iterator
15697  {
15698  return m_listCustom.begin();
15699  }
15700 
15702  inline std::list<CParameter *>::iterator
15703  endCustom (void)
15704  {
15705  return m_listCustom.end();
15706  }
15707 
15709  inline void
15711  {
15712  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15713  }
15714 
15716  inline int
15718  {
15719  return (int) (m_listCustom.size());
15720  }
15721 
15722  EResultCode
15724  addCustom (
15725  CParameter * pValue);
15726 
15727 
15728 };
15729 
15730 
15767 class CImpinjRFPowerSweep : public CParameter
15768 {
15769  public:
15770  CImpinjRFPowerSweep (void);
15771  ~CImpinjRFPowerSweep (void);
15772 
15775 
15776  static const CFieldDescriptor * const
15777  s_apFieldDescriptorTable[];
15778 
15779  static const CTypeDescriptor
15780  s_typeDescriptor;
15781 
15782  void
15783  decodeFields (
15784  CDecoderStream * pDecoderStream);
15785 
15786  void
15787  assimilateSubParameters (
15788  CErrorDetails * pError);
15789 
15790  void
15791  encode (
15792  CEncoderStream * pEncoderStream) const;
15793 
15794 
15795  llrp_bool_t
15796  isAllowedIn (
15797  const CTypeDescriptor * pEnclosingElementType) const;
15798 
15799 
15800  static CElement *
15801  s_construct (void);
15802 
15803  static void
15804  s_decodeFields (
15805  CDecoderStream * pDecoderStream,
15806  CElement * pElement);
15808 
15809 
15810  protected:
15811  llrp_u1_t m_EnableRFPowerSweep;
15812 
15815  public:
15816  static const CFieldDescriptor
15817  s_fdEnableRFPowerSweep;
15819 
15821  inline llrp_u1_t
15823  {
15824  return m_EnableRFPowerSweep;
15825  }
15826 
15828  inline void
15830  llrp_u1_t value)
15831  {
15832  m_EnableRFPowerSweep = value;
15833  }
15834 
15835 
15836  protected:
15837  llrp_u16_t m_MinimumPowerLevel;
15838 
15841  public:
15842  static const CFieldDescriptor
15843  s_fdMinimumPowerLevel;
15845 
15847  inline llrp_u16_t
15849  {
15850  return m_MinimumPowerLevel;
15851  }
15852 
15854  inline void
15856  llrp_u16_t value)
15857  {
15858  m_MinimumPowerLevel = value;
15859  }
15860 
15861 
15862  protected:
15863  llrp_u16_t m_PowerLevelStepSize;
15864 
15867  public:
15868  static const CFieldDescriptor
15869  s_fdPowerLevelStepSize;
15871 
15873  inline llrp_u16_t
15875  {
15876  return m_PowerLevelStepSize;
15877  }
15878 
15880  inline void
15882  llrp_u16_t value)
15883  {
15884  m_PowerLevelStepSize = value;
15885  }
15886 
15887 
15888 
15889  protected:
15890  std::list<CParameter *> m_listCustom;
15891 
15892  public:
15894  inline std::list<CParameter *>::iterator
15896  {
15897  return m_listCustom.begin();
15898  }
15899 
15901  inline std::list<CParameter *>::iterator
15902  endCustom (void)
15903  {
15904  return m_listCustom.end();
15905  }
15906 
15908  inline void
15910  {
15911  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15912  }
15913 
15915  inline int
15917  {
15918  return (int) (m_listCustom.size());
15919  }
15920 
15921  EResultCode
15923  addCustom (
15924  CParameter * pValue);
15925 
15926 
15927 };
15928 
15929 
15944 extern void
15946  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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
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.
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.
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.
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 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.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
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.
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.
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 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.
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...
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.
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.
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.
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.
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.
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.
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.
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.
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.
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_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.
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.
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.
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.
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.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
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.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.