LTKCPP-- LLRP Toolkit C Plus Plus Library
x86_64/src/generated/out_impinj_ltkcpp.h
1 
2 /*
3  * Generated file - DO NOT EDIT
4  *
5  * This is the header file for the LLRP Tool Kit (LTK)
6  * C++ (aka cpp) implementation. It is generated into a .inc file
7  * that is included by a platform specific .h header file.
8  * That .h file takes care of prerequisites needed by this file.
9  */
10 
11 
12 /*
13  * Message classes - forward decls
14  */
15 
16 
17 /* Custom messages */
18 
23 
24 /*
25  * Parameter classes - forward decls
26  */
27 
28 
29 /* Custom parameters */
30 
37 class CImpinjHubVersions;
50 class CImpinjSetQTConfig;
52 class CImpinjGetQTConfig;
61 class CImpinjPeakRSSI;
63 class CImpinjLoopSpec;
65 class CImpinjGGASentence;
66 class CImpinjRMCSentence;
75 class CImpinjTxPower;
87 class CImpinjLISpec;
93 class CImpinjDISpec;
109 class CImpinjTIDParity;
110 class CImpinjMarginRead;
112 class CImpinjBLEVersion;
114 class CImpinjRFPowerSweep;
116 class CImpinjAuthenticate;
119 
120 /*
121  * Vendor descriptor declarations.
122  */
123 
124 extern const CVendorDescriptor
125 g_vdescImpinj;
126 
127 
128 /*
129  * Namespace descriptor declarations.
130  */
131 
132 extern const CNamespaceDescriptor
133 g_nsdescImpinj;
134 
135 
136 /*
137  * Enumeration definitions and declarations of
138  * enumeration string tables.
139  */
140 
141 
173 enum EImpinjRequestedDataType
174 {
175 
176  ImpinjRequestedDataType_All_Capabilities = 1000,
177  ImpinjRequestedDataType_Impinj_Detailed_Version = 1001,
178  ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002,
179  ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003,
180  ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004,
181  ImpinjRequestedDataType_All_Configuration = 2000,
182  ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001,
183  ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003,
184  ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004,
185  ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005,
186  ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006,
187  ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007,
188  ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008,
189  ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009,
190  ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010,
191  ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011,
192  ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012,
193  ImpinjRequestedDataType_Impinj_Location_Configuration = 2013,
194  ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014,
195  ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015,
196  ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017,
197  ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018,
198 };
199 
200 extern const SEnumTableEntry
201 g_estImpinjRequestedDataType[];
202 
203 
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  ImpinjRegulatoryRegion_Paraguay_918_928_MHz = 31,
273  ImpinjRegulatoryRegion_Morocco = 32,
274 };
275 
276 extern const SEnumTableEntry
277 g_estImpinjRegulatoryRegion[];
278 
279 
294 enum EImpinjInventorySearchType
295 {
296 
297  ImpinjInventorySearchType_Reader_Selected = 0,
298  ImpinjInventorySearchType_Single_Target = 1,
299  ImpinjInventorySearchType_Dual_Target = 2,
300  ImpinjInventorySearchType_Single_Target_With_Suppression = 3,
301  ImpinjInventorySearchType_No_Target = 4,
302  ImpinjInventorySearchType_Single_Target_BtoA = 5,
303  ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6,
304 };
305 
306 extern const SEnumTableEntry
307 g_estImpinjInventorySearchType[];
308 
309 
320 enum EImpinjFixedFrequencyMode
321 {
322 
323  ImpinjFixedFrequencyMode_Disabled = 0,
324  ImpinjFixedFrequencyMode_Auto_Select = 1,
325  ImpinjFixedFrequencyMode_Channel_List = 2,
326 };
327 
328 extern const SEnumTableEntry
329 g_estImpinjFixedFrequencyMode[];
330 
331 
341 enum EImpinjReducedPowerMode
342 {
343 
344  ImpinjReducedPowerMode_Disabled = 0,
345  ImpinjReducedPowerMode_Enabled = 1,
346 };
347 
348 extern const SEnumTableEntry
349 g_estImpinjReducedPowerMode[];
350 
351 
361 enum EImpinjLowDutyCycleMode
362 {
363 
364  ImpinjLowDutyCycleMode_Disabled = 0,
365  ImpinjLowDutyCycleMode_Enabled = 1,
366 };
367 
368 extern const SEnumTableEntry
369 g_estImpinjLowDutyCycleMode[];
370 
371 
381 enum EImpinjLinkMonitorMode
382 {
383 
384  ImpinjLinkMonitorMode_Disabled = 0,
385  ImpinjLinkMonitorMode_Enabled = 1,
386 };
387 
388 extern const SEnumTableEntry
389 g_estImpinjLinkMonitorMode[];
390 
391 
401 enum EImpinjReportBufferMode
402 {
403 
404  ImpinjReportBufferMode_Normal = 0,
405  ImpinjReportBufferMode_Low_Latency = 1,
406 };
407 
408 extern const SEnumTableEntry
409 g_estImpinjReportBufferMode[];
410 
411 
426 enum EImpinjBlockPermalockResultType
427 {
428 
429  ImpinjBlockPermalockResultType_Success = 0,
430  ImpinjBlockPermalockResultType_Insufficient_Power = 1,
431  ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2,
432  ImpinjBlockPermalockResultType_No_Response_From_Tag = 3,
433  ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4,
434  ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5,
435  ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6,
436 };
437 
438 extern const SEnumTableEntry
439 g_estImpinjBlockPermalockResultType[];
440 
441 
455 enum EImpinjGetBlockPermalockStatusResultType
456 {
457 
458  ImpinjGetBlockPermalockStatusResultType_Success = 0,
459  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1,
460  ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2,
461  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3,
462  ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4,
463  ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5,
464 };
465 
466 extern const SEnumTableEntry
467 g_estImpinjGetBlockPermalockStatusResultType[];
468 
469 
480 enum EImpinjQTDataProfile
481 {
482 
483  ImpinjQTDataProfile_Unknown = 0,
484  ImpinjQTDataProfile_Private = 1,
485  ImpinjQTDataProfile_Public = 2,
486 };
487 
488 extern const SEnumTableEntry
489 g_estImpinjQTDataProfile[];
490 
491 
502 enum EImpinjQTAccessRange
503 {
504 
505  ImpinjQTAccessRange_Unknown = 0,
506  ImpinjQTAccessRange_Normal_Range = 1,
507  ImpinjQTAccessRange_Short_Range = 2,
508 };
509 
510 extern const SEnumTableEntry
511 g_estImpinjQTAccessRange[];
512 
513 
524 enum EImpinjQTPersistence
525 {
526 
527  ImpinjQTPersistence_Unknown = 0,
528  ImpinjQTPersistence_Temporary = 1,
529  ImpinjQTPersistence_Permanent = 2,
530 };
531 
532 extern const SEnumTableEntry
533 g_estImpinjQTPersistence[];
534 
535 
549 enum EImpinjSetQTConfigResultType
550 {
551 
552  ImpinjSetQTConfigResultType_Success = 0,
553  ImpinjSetQTConfigResultType_Insufficient_Power = 1,
554  ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2,
555  ImpinjSetQTConfigResultType_No_Response_From_Tag = 3,
556  ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4,
557  ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5,
558 };
559 
560 extern const SEnumTableEntry
561 g_estImpinjSetQTConfigResultType[];
562 
563 
576 enum EImpinjGetQTConfigResultType
577 {
578 
579  ImpinjGetQTConfigResultType_Success = 0,
580  ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1,
581  ImpinjGetQTConfigResultType_No_Response_From_Tag = 2,
582  ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3,
583  ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4,
584 };
585 
586 extern const SEnumTableEntry
587 g_estImpinjGetQTConfigResultType[];
588 
589 
599 enum EImpinjSerializedTIDMode
600 {
601 
602  ImpinjSerializedTIDMode_Disabled = 0,
603  ImpinjSerializedTIDMode_Enabled = 1,
604 };
605 
606 extern const SEnumTableEntry
607 g_estImpinjSerializedTIDMode[];
608 
609 
619 enum EImpinjRFPhaseAngleMode
620 {
621 
622  ImpinjRFPhaseAngleMode_Disabled = 0,
623  ImpinjRFPhaseAngleMode_Enabled = 1,
624 };
625 
626 extern const SEnumTableEntry
627 g_estImpinjRFPhaseAngleMode[];
628 
629 
639 enum EImpinjPeakRSSIMode
640 {
641 
642  ImpinjPeakRSSIMode_Disabled = 0,
643  ImpinjPeakRSSIMode_Enabled = 1,
644 };
645 
646 extern const SEnumTableEntry
647 g_estImpinjPeakRSSIMode[];
648 
649 
659 enum EImpinjGPSCoordinatesMode
660 {
661 
662  ImpinjGPSCoordinatesMode_Disabled = 0,
663  ImpinjGPSCoordinatesMode_Enabled = 1,
664 };
665 
666 extern const SEnumTableEntry
667 g_estImpinjGPSCoordinatesMode[];
668 
669 
684 enum EImpinjAdvancedGPOMode
685 {
686 
687  ImpinjAdvancedGPOMode_Normal = 0,
688  ImpinjAdvancedGPOMode_Pulsed = 1,
689  ImpinjAdvancedGPOMode_Reader_Operational_Status = 2,
690  ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3,
691  ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4,
692  ImpinjAdvancedGPOMode_Network_Connection_Status = 5,
693  ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6,
694 };
695 
696 extern const SEnumTableEntry
697 g_estImpinjAdvancedGPOMode[];
698 
699 
709 enum EImpinjOptimizedReadMode
710 {
711 
712  ImpinjOptimizedReadMode_Disabled = 0,
713  ImpinjOptimizedReadMode_Enabled = 1,
714 };
715 
716 extern const SEnumTableEntry
717 g_estImpinjOptimizedReadMode[];
718 
719 
729 enum EImpinjAccessSpecOrderingMode
730 {
731 
732  ImpinjAccessSpecOrderingMode_FIFO = 0,
733  ImpinjAccessSpecOrderingMode_Ascending = 1,
734 };
735 
736 extern const SEnumTableEntry
737 g_estImpinjAccessSpecOrderingMode[];
738 
739 
749 enum EImpinjRFDopplerFrequencyMode
750 {
751 
752  ImpinjRFDopplerFrequencyMode_Disabled = 0,
753  ImpinjRFDopplerFrequencyMode_Enabled = 1,
754 };
755 
756 extern const SEnumTableEntry
757 g_estImpinjRFDopplerFrequencyMode[];
758 
759 
769 enum EImpinjTxPowerReportingModeEnum
770 {
771 
772  ImpinjTxPowerReportingModeEnum_Disabled = 0,
773  ImpinjTxPowerReportingModeEnum_Enabled = 1,
774 };
775 
776 extern const SEnumTableEntry
777 g_estImpinjTxPowerReportingModeEnum[];
778 
779 
790 enum EImpinjHubConnectedType
791 {
792 
793  ImpinjHubConnectedType_Unknown = 0,
794  ImpinjHubConnectedType_Disconnected = 1,
795  ImpinjHubConnectedType_Connected = 2,
796 };
797 
798 extern const SEnumTableEntry
799 g_estImpinjHubConnectedType[];
800 
801 
818 enum EImpinjHubFaultType
819 {
820 
821  ImpinjHubFaultType_No_Fault = 0,
822  ImpinjHubFaultType_RF_Power = 1,
823  ImpinjHubFaultType_RF_Power_On_Hub_1 = 2,
824  ImpinjHubFaultType_RF_Power_On_Hub_2 = 3,
825  ImpinjHubFaultType_RF_Power_On_Hub_3 = 4,
826  ImpinjHubFaultType_RF_Power_On_Hub_4 = 5,
827  ImpinjHubFaultType_No_Init = 6,
828  ImpinjHubFaultType_Serial_Overflow = 7,
829  ImpinjHubFaultType_Disconnected = 8,
830 };
831 
832 extern const SEnumTableEntry
833 g_estImpinjHubFaultType[];
834 
835 
846 enum EImpinjLocationReportType
847 {
848 
849  ImpinjLocationReportType_Entry = 0,
850  ImpinjLocationReportType_Update = 1,
851  ImpinjLocationReportType_Exit = 2,
852 };
853 
854 extern const SEnumTableEntry
855 g_estImpinjLocationReportType[];
856 
857 
901 enum EImpinjDirectionFieldOfView
902 {
903 
904  ImpinjDirectionFieldOfView_ReaderSelected = 0,
905  ImpinjDirectionFieldOfView_Wide = 1,
906  ImpinjDirectionFieldOfView_Narrow = 2,
907 };
908 
909 extern const SEnumTableEntry
910 g_estImpinjDirectionFieldOfView[];
911 
912 
947 enum EImpinjDirectionRFMode
948 {
949 
950  ImpinjDirectionRFMode_HighSensitivity = 0,
951  ImpinjDirectionRFMode_HighPerformance = 1,
952 };
953 
954 extern const SEnumTableEntry
955 g_estImpinjDirectionRFMode[];
956 
957 
1007 enum EImpinjDirectionDiagnosticReportLevel
1008 {
1009 
1010  ImpinjDirectionDiagnosticReportLevel_Off = 0,
1011  ImpinjDirectionDiagnosticReportLevel_Basic = 1,
1012  ImpinjDirectionDiagnosticReportLevel_Extended = 2,
1013  ImpinjDirectionDiagnosticReportLevel_Debug = 3,
1014 };
1015 
1016 extern const SEnumTableEntry
1017 g_estImpinjDirectionDiagnosticReportLevel[];
1018 
1019 
1058 enum EImpinjDirectionReportType
1059 {
1060 
1061  ImpinjDirectionReportType_Entry = 0,
1062  ImpinjDirectionReportType_Update = 1,
1063  ImpinjDirectionReportType_Exit = 2,
1064 };
1065 
1066 extern const SEnumTableEntry
1067 g_estImpinjDirectionReportType[];
1068 
1069 
1108 enum EImpinjDirectionTagPopulationStatus
1109 {
1110 
1111  ImpinjDirectionTagPopulationStatus_OK = 0,
1112  ImpinjDirectionTagPopulationStatus_UserOverflow = 1,
1113  ImpinjDirectionTagPopulationStatus_SystemOverflow = 2,
1114 };
1115 
1116 extern const SEnumTableEntry
1117 g_estImpinjDirectionTagPopulationStatus[];
1118 
1119 
1129 enum EImpinjIntelligentAntennaMode
1130 {
1131 
1132  ImpinjIntelligentAntennaMode_Disabled = 0,
1133  ImpinjIntelligentAntennaMode_Enabled = 1,
1134 };
1135 
1136 extern const SEnumTableEntry
1137 g_estImpinjIntelligentAntennaMode[];
1138 
1139 
1151 enum EImpinjAntennaPolarizationType
1152 {
1153 
1154  ImpinjAntennaPolarizationType_LinearHorizontal = 0,
1155  ImpinjAntennaPolarizationType_LinearVertical = 1,
1156  ImpinjAntennaPolarizationType_CircularRight = 2,
1157  ImpinjAntennaPolarizationType_CircularLeft = 3,
1158 };
1159 
1160 extern const SEnumTableEntry
1161 g_estImpinjAntennaPolarizationType[];
1162 
1163 
1180 enum EImpinjMarginReadResultType
1181 {
1182 
1183  ImpinjMarginReadResultType_Success = 0,
1184  ImpinjMarginReadResultType_Failure = 1,
1185  ImpinjMarginReadResultType_Insufficient_Power = 2,
1186  ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3,
1187  ImpinjMarginReadResultType_No_Response_From_Tag = 4,
1188  ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5,
1189  ImpinjMarginReadResultType_Incorrect_Password_Error = 6,
1190  ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7,
1191  ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8,
1192 };
1193 
1194 extern const SEnumTableEntry
1195 g_estImpinjMarginReadResultType[];
1196 
1197 
1211 enum EImpinjAuthenticateResultType
1212 {
1213 
1214  ImpinjAuthenticateResultType_Success = 0,
1215  ImpinjAuthenticateResultType_Insufficient_Power = 1,
1216  ImpinjAuthenticateResultType_Not_Supported_Error = 2,
1217  ImpinjAuthenticateResultType_Nonspecific_Tag_Error = 3,
1218  ImpinjAuthenticateResultType_Nonspecific_Reader_Error = 4,
1219  ImpinjAuthenticateResultType_No_Response_From_Tag = 5,
1220 };
1221 
1222 extern const SEnumTableEntry
1223 g_estImpinjAuthenticateResultType[];
1224 
1225 
1235 enum EImpinjTagFilterVerificationMode
1236 {
1237 
1238  ImpinjTagFilterVerificationMode_Disabled = 0,
1239  ImpinjTagFilterVerificationMode_Active = 1,
1240 };
1241 
1242 extern const SEnumTableEntry
1243 g_estImpinjTagFilterVerificationMode[];
1244 
1245 
1251 
1275 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1276 {
1277  public:
1279  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1280 
1283 
1284  static const CFieldDescriptor * const
1285  s_apFieldDescriptorTable[];
1286 
1287  static const CTypeDescriptor
1288  s_typeDescriptor;
1289 
1290  void
1291  decodeFields (
1292  CDecoderStream * pDecoderStream);
1293 
1294  void
1295  assimilateSubParameters (
1296  CErrorDetails * pError);
1297 
1298  void
1299  encode (
1300  CEncoderStream * pEncoderStream) const;
1301 
1302 
1303 
1304  static CElement *
1305  s_construct (void);
1306 
1307  static void
1308  s_decodeFields (
1309  CDecoderStream * pDecoderStream,
1310  CElement * pElement);
1312 
1313 
1314 
1315  protected:
1316  std::list<CParameter *> m_listCustom;
1317 
1318  public:
1320  inline std::list<CParameter *>::iterator
1322  {
1323  return m_listCustom.begin();
1324  }
1325 
1327  inline std::list<CParameter *>::iterator
1328  endCustom (void)
1329  {
1330  return m_listCustom.end();
1331  }
1332 
1334  inline void
1336  {
1337  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1338  }
1339 
1341  inline int
1343  {
1344  return (int) (m_listCustom.size());
1345  }
1346 
1347  EResultCode
1349  addCustom (
1350  CParameter * pValue);
1351 
1352 
1353 };
1354 
1355 
1379 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1380 {
1381  public:
1384 
1387 
1388  static const CFieldDescriptor * const
1389  s_apFieldDescriptorTable[];
1390 
1391  static const CTypeDescriptor
1392  s_typeDescriptor;
1393 
1394  void
1395  decodeFields (
1396  CDecoderStream * pDecoderStream);
1397 
1398  void
1399  assimilateSubParameters (
1400  CErrorDetails * pError);
1401 
1402  void
1403  encode (
1404  CEncoderStream * pEncoderStream) const;
1405 
1406 
1407 
1408  static CElement *
1409  s_construct (void);
1410 
1411  static void
1412  s_decodeFields (
1413  CDecoderStream * pDecoderStream,
1414  CElement * pElement);
1416 
1417 
1418 
1419  protected:
1420  CLLRPStatus * m_pLLRPStatus;
1421 
1422  public:
1424  inline CLLRPStatus *
1426  {
1427  return m_pLLRPStatus;
1428  }
1429 
1431  EResultCode
1432  setLLRPStatus (
1433  CLLRPStatus * pValue);
1434 
1435 
1436  protected:
1437  std::list<CParameter *> m_listCustom;
1438 
1439  public:
1441  inline std::list<CParameter *>::iterator
1443  {
1444  return m_listCustom.begin();
1445  }
1446 
1448  inline std::list<CParameter *>::iterator
1449  endCustom (void)
1450  {
1451  return m_listCustom.end();
1452  }
1453 
1455  inline void
1457  {
1458  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1459  }
1460 
1462  inline int
1464  {
1465  return (int) (m_listCustom.size());
1466  }
1467 
1468  EResultCode
1470  addCustom (
1471  CParameter * pValue);
1472 
1473 
1474 };
1475 
1476 
1510 class CIMPINJ_SAVE_SETTINGS : public CMessage
1511 {
1512  public:
1513  CIMPINJ_SAVE_SETTINGS (void);
1514  ~CIMPINJ_SAVE_SETTINGS (void);
1515 
1518 
1519  static const CFieldDescriptor * const
1520  s_apFieldDescriptorTable[];
1521 
1522  static const CTypeDescriptor
1523  s_typeDescriptor;
1524 
1525  void
1526  decodeFields (
1527  CDecoderStream * pDecoderStream);
1528 
1529  void
1530  assimilateSubParameters (
1531  CErrorDetails * pError);
1532 
1533  void
1534  encode (
1535  CEncoderStream * pEncoderStream) const;
1536 
1537 
1538 
1539  static CElement *
1540  s_construct (void);
1541 
1542  static void
1543  s_decodeFields (
1544  CDecoderStream * pDecoderStream,
1545  CElement * pElement);
1547 
1548 
1549  protected:
1550  llrp_u1_t m_SaveConfiguration;
1551 
1554  public:
1555  static const CFieldDescriptor
1556  s_fdSaveConfiguration;
1558 
1560  inline llrp_u1_t
1562  {
1563  return m_SaveConfiguration;
1564  }
1565 
1567  inline void
1569  llrp_u1_t value)
1570  {
1571  m_SaveConfiguration = value;
1572  }
1573 
1574 
1575 
1576  protected:
1577  std::list<CParameter *> m_listCustom;
1578 
1579  public:
1581  inline std::list<CParameter *>::iterator
1583  {
1584  return m_listCustom.begin();
1585  }
1586 
1588  inline std::list<CParameter *>::iterator
1589  endCustom (void)
1590  {
1591  return m_listCustom.end();
1592  }
1593 
1595  inline void
1597  {
1598  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1599  }
1600 
1602  inline int
1604  {
1605  return (int) (m_listCustom.size());
1606  }
1607 
1608  EResultCode
1610  addCustom (
1611  CParameter * pValue);
1612 
1613 
1614 };
1615 
1616 
1640 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1641 {
1642  public:
1645 
1648 
1649  static const CFieldDescriptor * const
1650  s_apFieldDescriptorTable[];
1651 
1652  static const CTypeDescriptor
1653  s_typeDescriptor;
1654 
1655  void
1656  decodeFields (
1657  CDecoderStream * pDecoderStream);
1658 
1659  void
1660  assimilateSubParameters (
1661  CErrorDetails * pError);
1662 
1663  void
1664  encode (
1665  CEncoderStream * pEncoderStream) const;
1666 
1667 
1668 
1669  static CElement *
1670  s_construct (void);
1671 
1672  static void
1673  s_decodeFields (
1674  CDecoderStream * pDecoderStream,
1675  CElement * pElement);
1677 
1678 
1679 
1680  protected:
1681  CLLRPStatus * m_pLLRPStatus;
1682 
1683  public:
1685  inline CLLRPStatus *
1687  {
1688  return m_pLLRPStatus;
1689  }
1690 
1692  EResultCode
1693  setLLRPStatus (
1694  CLLRPStatus * pValue);
1695 
1696 
1697  protected:
1698  std::list<CParameter *> m_listCustom;
1699 
1700  public:
1702  inline std::list<CParameter *>::iterator
1704  {
1705  return m_listCustom.begin();
1706  }
1707 
1709  inline std::list<CParameter *>::iterator
1710  endCustom (void)
1711  {
1712  return m_listCustom.end();
1713  }
1714 
1716  inline void
1718  {
1719  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1720  }
1721 
1723  inline int
1725  {
1726  return (int) (m_listCustom.size());
1727  }
1728 
1729  EResultCode
1731  addCustom (
1732  CParameter * pValue);
1733 
1734 
1735 };
1736 
1737 
1745 
1768 class CImpinjRequestedData : public CParameter
1769 {
1770  public:
1771  CImpinjRequestedData (void);
1772  ~CImpinjRequestedData (void);
1773 
1776 
1777  static const CFieldDescriptor * const
1778  s_apFieldDescriptorTable[];
1779 
1780  static const CTypeDescriptor
1781  s_typeDescriptor;
1782 
1783  void
1784  decodeFields (
1785  CDecoderStream * pDecoderStream);
1786 
1787  void
1788  assimilateSubParameters (
1789  CErrorDetails * pError);
1790 
1791  void
1792  encode (
1793  CEncoderStream * pEncoderStream) const;
1794 
1795 
1796  llrp_bool_t
1797  isAllowedIn (
1798  const CTypeDescriptor * pEnclosingElementType) const;
1799 
1800 
1801  static CElement *
1802  s_construct (void);
1803 
1804  static void
1805  s_decodeFields (
1806  CDecoderStream * pDecoderStream,
1807  CElement * pElement);
1809 
1810 
1811  protected:
1812  EImpinjRequestedDataType m_eRequestedData;
1813 
1816  public:
1817  static const CFieldDescriptor
1818  s_fdRequestedData;
1820 
1822  inline EImpinjRequestedDataType
1824  {
1825  return m_eRequestedData;
1826  }
1827 
1829  inline void
1831  EImpinjRequestedDataType value)
1832  {
1833  m_eRequestedData = value;
1834  }
1835 
1836 
1837 
1838  protected:
1839  std::list<CParameter *> m_listCustom;
1840 
1841  public:
1843  inline std::list<CParameter *>::iterator
1845  {
1846  return m_listCustom.begin();
1847  }
1848 
1850  inline std::list<CParameter *>::iterator
1851  endCustom (void)
1852  {
1853  return m_listCustom.end();
1854  }
1855 
1857  inline void
1859  {
1860  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1861  }
1862 
1864  inline int
1866  {
1867  return (int) (m_listCustom.size());
1868  }
1869 
1870  EResultCode
1872  addCustom (
1873  CParameter * pValue);
1874 
1875 
1876 };
1877 
1878 
1907 class CImpinjSubRegulatoryRegion : public CParameter
1908 {
1909  public:
1912 
1915 
1916  static const CFieldDescriptor * const
1917  s_apFieldDescriptorTable[];
1918 
1919  static const CTypeDescriptor
1920  s_typeDescriptor;
1921 
1922  void
1923  decodeFields (
1924  CDecoderStream * pDecoderStream);
1925 
1926  void
1927  assimilateSubParameters (
1928  CErrorDetails * pError);
1929 
1930  void
1931  encode (
1932  CEncoderStream * pEncoderStream) const;
1933 
1934 
1935  llrp_bool_t
1936  isAllowedIn (
1937  const CTypeDescriptor * pEnclosingElementType) const;
1938 
1939 
1940  static CElement *
1941  s_construct (void);
1942 
1943  static void
1944  s_decodeFields (
1945  CDecoderStream * pDecoderStream,
1946  CElement * pElement);
1948 
1949 
1950  protected:
1951  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1952 
1955  public:
1956  static const CFieldDescriptor
1957  s_fdRegulatoryRegion;
1959 
1961  inline EImpinjRegulatoryRegion
1963  {
1964  return m_eRegulatoryRegion;
1965  }
1966 
1968  inline void
1970  EImpinjRegulatoryRegion value)
1971  {
1972  m_eRegulatoryRegion = value;
1973  }
1974 
1975 
1976 
1977  protected:
1978  std::list<CParameter *> m_listCustom;
1979 
1980  public:
1982  inline std::list<CParameter *>::iterator
1984  {
1985  return m_listCustom.begin();
1986  }
1987 
1989  inline std::list<CParameter *>::iterator
1990  endCustom (void)
1991  {
1992  return m_listCustom.end();
1993  }
1994 
1996  inline void
1998  {
1999  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2000  }
2001 
2003  inline int
2005  {
2006  return (int) (m_listCustom.size());
2007  }
2008 
2009  EResultCode
2011  addCustom (
2012  CParameter * pValue);
2013 
2014 
2015 };
2016 
2017 
2042 class CImpinjInventorySearchMode : public CParameter
2043 {
2044  public:
2047 
2050 
2051  static const CFieldDescriptor * const
2052  s_apFieldDescriptorTable[];
2053 
2054  static const CTypeDescriptor
2055  s_typeDescriptor;
2056 
2057  void
2058  decodeFields (
2059  CDecoderStream * pDecoderStream);
2060 
2061  void
2062  assimilateSubParameters (
2063  CErrorDetails * pError);
2064 
2065  void
2066  encode (
2067  CEncoderStream * pEncoderStream) const;
2068 
2069 
2070  llrp_bool_t
2071  isAllowedIn (
2072  const CTypeDescriptor * pEnclosingElementType) const;
2073 
2074 
2075  static CElement *
2076  s_construct (void);
2077 
2078  static void
2079  s_decodeFields (
2080  CDecoderStream * pDecoderStream,
2081  CElement * pElement);
2083 
2084 
2085  protected:
2086  EImpinjInventorySearchType m_eInventorySearchMode;
2087 
2090  public:
2091  static const CFieldDescriptor
2092  s_fdInventorySearchMode;
2094 
2096  inline EImpinjInventorySearchType
2098  {
2099  return m_eInventorySearchMode;
2100  }
2101 
2103  inline void
2105  EImpinjInventorySearchType value)
2106  {
2107  m_eInventorySearchMode = value;
2108  }
2109 
2110 
2111 
2112  protected:
2113  std::list<CParameter *> m_listCustom;
2114 
2115  public:
2117  inline std::list<CParameter *>::iterator
2119  {
2120  return m_listCustom.begin();
2121  }
2122 
2124  inline std::list<CParameter *>::iterator
2125  endCustom (void)
2126  {
2127  return m_listCustom.end();
2128  }
2129 
2131  inline void
2133  {
2134  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2135  }
2136 
2138  inline int
2140  {
2141  return (int) (m_listCustom.size());
2142  }
2143 
2144  EResultCode
2146  addCustom (
2147  CParameter * pValue);
2148 
2149 
2150 };
2151 
2152 
2182 class CImpinjFixedFrequencyList : public CParameter
2183 {
2184  public:
2186  ~CImpinjFixedFrequencyList (void);
2187 
2190 
2191  static const CFieldDescriptor * const
2192  s_apFieldDescriptorTable[];
2193 
2194  static const CTypeDescriptor
2195  s_typeDescriptor;
2196 
2197  void
2198  decodeFields (
2199  CDecoderStream * pDecoderStream);
2200 
2201  void
2202  assimilateSubParameters (
2203  CErrorDetails * pError);
2204 
2205  void
2206  encode (
2207  CEncoderStream * pEncoderStream) const;
2208 
2209 
2210  llrp_bool_t
2211  isAllowedIn (
2212  const CTypeDescriptor * pEnclosingElementType) const;
2213 
2214 
2215  static CElement *
2216  s_construct (void);
2217 
2218  static void
2219  s_decodeFields (
2220  CDecoderStream * pDecoderStream,
2221  CElement * pElement);
2223 
2224 
2225  protected:
2226  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
2227 
2230  public:
2231  static const CFieldDescriptor
2232  s_fdFixedFrequencyMode;
2234 
2236  inline EImpinjFixedFrequencyMode
2238  {
2239  return m_eFixedFrequencyMode;
2240  }
2241 
2243  inline void
2245  EImpinjFixedFrequencyMode value)
2246  {
2247  m_eFixedFrequencyMode = value;
2248  }
2249 
2250 
2251  protected:
2252  llrp_u16v_t m_ChannelList;
2253 
2256  public:
2257  static const CFieldDescriptor
2258  s_fdChannelList;
2260 
2262  inline llrp_u16v_t
2264  {
2265  return m_ChannelList;
2266  }
2267 
2269  inline void
2271  llrp_u16v_t value)
2272  {
2273  m_ChannelList = value;
2274  }
2275 
2276 
2277 
2278  protected:
2279  std::list<CParameter *> m_listCustom;
2280 
2281  public:
2283  inline std::list<CParameter *>::iterator
2285  {
2286  return m_listCustom.begin();
2287  }
2288 
2290  inline std::list<CParameter *>::iterator
2291  endCustom (void)
2292  {
2293  return m_listCustom.end();
2294  }
2295 
2297  inline void
2299  {
2300  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2301  }
2302 
2304  inline int
2306  {
2307  return (int) (m_listCustom.size());
2308  }
2309 
2310  EResultCode
2312  addCustom (
2313  CParameter * pValue);
2314 
2315 
2316 };
2317 
2318 
2348 class CImpinjReducedPowerFrequencyList : public CParameter
2349 {
2350  public:
2353 
2356 
2357  static const CFieldDescriptor * const
2358  s_apFieldDescriptorTable[];
2359 
2360  static const CTypeDescriptor
2361  s_typeDescriptor;
2362 
2363  void
2364  decodeFields (
2365  CDecoderStream * pDecoderStream);
2366 
2367  void
2368  assimilateSubParameters (
2369  CErrorDetails * pError);
2370 
2371  void
2372  encode (
2373  CEncoderStream * pEncoderStream) const;
2374 
2375 
2376  llrp_bool_t
2377  isAllowedIn (
2378  const CTypeDescriptor * pEnclosingElementType) const;
2379 
2380 
2381  static CElement *
2382  s_construct (void);
2383 
2384  static void
2385  s_decodeFields (
2386  CDecoderStream * pDecoderStream,
2387  CElement * pElement);
2389 
2390 
2391  protected:
2392  EImpinjReducedPowerMode m_eReducedPowerMode;
2393 
2396  public:
2397  static const CFieldDescriptor
2398  s_fdReducedPowerMode;
2400 
2402  inline EImpinjReducedPowerMode
2404  {
2405  return m_eReducedPowerMode;
2406  }
2407 
2409  inline void
2411  EImpinjReducedPowerMode value)
2412  {
2413  m_eReducedPowerMode = value;
2414  }
2415 
2416 
2417  protected:
2418  llrp_u16v_t m_ChannelList;
2419 
2422  public:
2423  static const CFieldDescriptor
2424  s_fdChannelList;
2426 
2428  inline llrp_u16v_t
2430  {
2431  return m_ChannelList;
2432  }
2433 
2435  inline void
2437  llrp_u16v_t value)
2438  {
2439  m_ChannelList = value;
2440  }
2441 
2442 
2443 
2444  protected:
2445  std::list<CParameter *> m_listCustom;
2446 
2447  public:
2449  inline std::list<CParameter *>::iterator
2451  {
2452  return m_listCustom.begin();
2453  }
2454 
2456  inline std::list<CParameter *>::iterator
2457  endCustom (void)
2458  {
2459  return m_listCustom.end();
2460  }
2461 
2463  inline void
2465  {
2466  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2467  }
2468 
2470  inline int
2472  {
2473  return (int) (m_listCustom.size());
2474  }
2475 
2476  EResultCode
2478  addCustom (
2479  CParameter * pValue);
2480 
2481 
2482 };
2483 
2484 
2514 class CImpinjLowDutyCycle : public CParameter
2515 {
2516  public:
2517  CImpinjLowDutyCycle (void);
2518  ~CImpinjLowDutyCycle (void);
2519 
2522 
2523  static const CFieldDescriptor * const
2524  s_apFieldDescriptorTable[];
2525 
2526  static const CTypeDescriptor
2527  s_typeDescriptor;
2528 
2529  void
2530  decodeFields (
2531  CDecoderStream * pDecoderStream);
2532 
2533  void
2534  assimilateSubParameters (
2535  CErrorDetails * pError);
2536 
2537  void
2538  encode (
2539  CEncoderStream * pEncoderStream) const;
2540 
2541 
2542  llrp_bool_t
2543  isAllowedIn (
2544  const CTypeDescriptor * pEnclosingElementType) const;
2545 
2546 
2547  static CElement *
2548  s_construct (void);
2549 
2550  static void
2551  s_decodeFields (
2552  CDecoderStream * pDecoderStream,
2553  CElement * pElement);
2555 
2556 
2557  protected:
2558  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2559 
2562  public:
2563  static const CFieldDescriptor
2564  s_fdLowDutyCycleMode;
2566 
2568  inline EImpinjLowDutyCycleMode
2570  {
2571  return m_eLowDutyCycleMode;
2572  }
2573 
2575  inline void
2577  EImpinjLowDutyCycleMode value)
2578  {
2579  m_eLowDutyCycleMode = value;
2580  }
2581 
2582 
2583  protected:
2584  llrp_u16_t m_EmptyFieldTimeout;
2585 
2588  public:
2589  static const CFieldDescriptor
2590  s_fdEmptyFieldTimeout;
2592 
2594  inline llrp_u16_t
2596  {
2597  return m_EmptyFieldTimeout;
2598  }
2599 
2601  inline void
2603  llrp_u16_t value)
2604  {
2605  m_EmptyFieldTimeout = value;
2606  }
2607 
2608 
2609  protected:
2610  llrp_u16_t m_FieldPingInterval;
2611 
2614  public:
2615  static const CFieldDescriptor
2616  s_fdFieldPingInterval;
2618 
2620  inline llrp_u16_t
2622  {
2623  return m_FieldPingInterval;
2624  }
2625 
2627  inline void
2629  llrp_u16_t value)
2630  {
2631  m_FieldPingInterval = value;
2632  }
2633 
2634 
2635 
2636  protected:
2637  std::list<CParameter *> m_listCustom;
2638 
2639  public:
2641  inline std::list<CParameter *>::iterator
2643  {
2644  return m_listCustom.begin();
2645  }
2646 
2648  inline std::list<CParameter *>::iterator
2649  endCustom (void)
2650  {
2651  return m_listCustom.end();
2652  }
2653 
2655  inline void
2657  {
2658  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2659  }
2660 
2662  inline int
2664  {
2665  return (int) (m_listCustom.size());
2666  }
2667 
2668  EResultCode
2670  addCustom (
2671  CParameter * pValue);
2672 
2673 
2674 };
2675 
2676 
2701 class CImpinjHubVersions : public CParameter
2702 {
2703  public:
2704  CImpinjHubVersions (void);
2705  ~CImpinjHubVersions (void);
2706 
2709 
2710  static const CFieldDescriptor * const
2711  s_apFieldDescriptorTable[];
2712 
2713  static const CTypeDescriptor
2714  s_typeDescriptor;
2715 
2716  void
2717  decodeFields (
2718  CDecoderStream * pDecoderStream);
2719 
2720  void
2721  assimilateSubParameters (
2722  CErrorDetails * pError);
2723 
2724  void
2725  encode (
2726  CEncoderStream * pEncoderStream) const;
2727 
2728 
2729  llrp_bool_t
2730  isAllowedIn (
2731  const CTypeDescriptor * pEnclosingElementType) const;
2732 
2733 
2734  static CElement *
2735  s_construct (void);
2736 
2737  static void
2738  s_decodeFields (
2739  CDecoderStream * pDecoderStream,
2740  CElement * pElement);
2742 
2743 
2744 
2745  protected:
2746  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2747 
2748  public:
2750  inline std::list<CImpinjArrayVersion *>::iterator
2752  {
2753  return m_listImpinjArrayVersion.begin();
2754  }
2755 
2757  inline std::list<CImpinjArrayVersion *>::iterator
2759  {
2760  return m_listImpinjArrayVersion.end();
2761  }
2762 
2764  inline void
2766  {
2767  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2768  }
2769 
2771  inline int
2773  {
2774  return (int) (m_listImpinjArrayVersion.size());
2775  }
2776 
2777  EResultCode
2779  addImpinjArrayVersion (
2780  CImpinjArrayVersion * pValue);
2781 
2782 
2783  protected:
2784  std::list<CParameter *> m_listCustom;
2785 
2786  public:
2788  inline std::list<CParameter *>::iterator
2790  {
2791  return m_listCustom.begin();
2792  }
2793 
2795  inline std::list<CParameter *>::iterator
2796  endCustom (void)
2797  {
2798  return m_listCustom.end();
2799  }
2800 
2802  inline void
2804  {
2805  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2806  }
2807 
2809  inline int
2811  {
2812  return (int) (m_listCustom.size());
2813  }
2814 
2815  EResultCode
2817  addCustom (
2818  CParameter * pValue);
2819 
2820 
2821 };
2822 
2823 
2856 class CImpinjDetailedVersion : public CParameter
2857 {
2858  public:
2859  CImpinjDetailedVersion (void);
2860  ~CImpinjDetailedVersion (void);
2861 
2864 
2865  static const CFieldDescriptor * const
2866  s_apFieldDescriptorTable[];
2867 
2868  static const CTypeDescriptor
2869  s_typeDescriptor;
2870 
2871  void
2872  decodeFields (
2873  CDecoderStream * pDecoderStream);
2874 
2875  void
2876  assimilateSubParameters (
2877  CErrorDetails * pError);
2878 
2879  void
2880  encode (
2881  CEncoderStream * pEncoderStream) const;
2882 
2883 
2884  llrp_bool_t
2885  isAllowedIn (
2886  const CTypeDescriptor * pEnclosingElementType) const;
2887 
2888 
2889  static CElement *
2890  s_construct (void);
2891 
2892  static void
2893  s_decodeFields (
2894  CDecoderStream * pDecoderStream,
2895  CElement * pElement);
2897 
2898 
2899  protected:
2900  llrp_utf8v_t m_ModelName;
2901 
2904  public:
2905  static const CFieldDescriptor
2906  s_fdModelName;
2908 
2910  inline llrp_utf8v_t
2912  {
2913  return m_ModelName;
2914  }
2915 
2917  inline void
2919  llrp_utf8v_t value)
2920  {
2921  m_ModelName = value;
2922  }
2923 
2924 
2925  protected:
2926  llrp_utf8v_t m_SerialNumber;
2927 
2930  public:
2931  static const CFieldDescriptor
2932  s_fdSerialNumber;
2934 
2936  inline llrp_utf8v_t
2938  {
2939  return m_SerialNumber;
2940  }
2941 
2943  inline void
2945  llrp_utf8v_t value)
2946  {
2947  m_SerialNumber = value;
2948  }
2949 
2950 
2951  protected:
2952  llrp_utf8v_t m_SoftwareVersion;
2953 
2956  public:
2957  static const CFieldDescriptor
2958  s_fdSoftwareVersion;
2960 
2962  inline llrp_utf8v_t
2964  {
2965  return m_SoftwareVersion;
2966  }
2967 
2969  inline void
2971  llrp_utf8v_t value)
2972  {
2973  m_SoftwareVersion = value;
2974  }
2975 
2976 
2977  protected:
2978  llrp_utf8v_t m_FirmwareVersion;
2979 
2982  public:
2983  static const CFieldDescriptor
2984  s_fdFirmwareVersion;
2986 
2988  inline llrp_utf8v_t
2990  {
2991  return m_FirmwareVersion;
2992  }
2993 
2995  inline void
2997  llrp_utf8v_t value)
2998  {
2999  m_FirmwareVersion = value;
3000  }
3001 
3002 
3003  protected:
3004  llrp_utf8v_t m_FPGAVersion;
3005 
3008  public:
3009  static const CFieldDescriptor
3010  s_fdFPGAVersion;
3012 
3014  inline llrp_utf8v_t
3016  {
3017  return m_FPGAVersion;
3018  }
3019 
3021  inline void
3023  llrp_utf8v_t value)
3024  {
3025  m_FPGAVersion = value;
3026  }
3027 
3028 
3029  protected:
3030  llrp_utf8v_t m_PCBAVersion;
3031 
3034  public:
3035  static const CFieldDescriptor
3036  s_fdPCBAVersion;
3038 
3040  inline llrp_utf8v_t
3042  {
3043  return m_PCBAVersion;
3044  }
3045 
3047  inline void
3049  llrp_utf8v_t value)
3050  {
3051  m_PCBAVersion = value;
3052  }
3053 
3054 
3055 
3056  protected:
3057  CImpinjHubVersions * m_pImpinjHubVersions;
3058 
3059  public:
3061  inline CImpinjHubVersions *
3063  {
3064  return m_pImpinjHubVersions;
3065  }
3066 
3068  EResultCode
3069  setImpinjHubVersions (
3070  CImpinjHubVersions * pValue);
3071 
3072 
3073  protected:
3074  CImpinjArrayVersion * m_pImpinjArrayVersion;
3075 
3076  public:
3078  inline CImpinjArrayVersion *
3080  {
3081  return m_pImpinjArrayVersion;
3082  }
3083 
3085  EResultCode
3086  setImpinjArrayVersion (
3087  CImpinjArrayVersion * pValue);
3088 
3089 
3090  protected:
3091  CImpinjBLEVersion * m_pImpinjBLEVersion;
3092 
3093  public:
3095  inline CImpinjBLEVersion *
3097  {
3098  return m_pImpinjBLEVersion;
3099  }
3100 
3102  EResultCode
3103  setImpinjBLEVersion (
3104  CImpinjBLEVersion * pValue);
3105 
3106 
3107  protected:
3108  std::list<CParameter *> m_listCustom;
3109 
3110  public:
3112  inline std::list<CParameter *>::iterator
3114  {
3115  return m_listCustom.begin();
3116  }
3117 
3119  inline std::list<CParameter *>::iterator
3120  endCustom (void)
3121  {
3122  return m_listCustom.end();
3123  }
3124 
3126  inline void
3128  {
3129  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3130  }
3131 
3133  inline int
3135  {
3136  return (int) (m_listCustom.size());
3137  }
3138 
3139  EResultCode
3141  addCustom (
3142  CParameter * pValue);
3143 
3144 
3145 };
3146 
3147 
3172 class CImpinjFrequencyCapabilities : public CParameter
3173 {
3174  public:
3177 
3180 
3181  static const CFieldDescriptor * const
3182  s_apFieldDescriptorTable[];
3183 
3184  static const CTypeDescriptor
3185  s_typeDescriptor;
3186 
3187  void
3188  decodeFields (
3189  CDecoderStream * pDecoderStream);
3190 
3191  void
3192  assimilateSubParameters (
3193  CErrorDetails * pError);
3194 
3195  void
3196  encode (
3197  CEncoderStream * pEncoderStream) const;
3198 
3199 
3200  llrp_bool_t
3201  isAllowedIn (
3202  const CTypeDescriptor * pEnclosingElementType) const;
3203 
3204 
3205  static CElement *
3206  s_construct (void);
3207 
3208  static void
3209  s_decodeFields (
3210  CDecoderStream * pDecoderStream,
3211  CElement * pElement);
3213 
3214 
3215  protected:
3216  llrp_u32v_t m_FrequencyList;
3217 
3220  public:
3221  static const CFieldDescriptor
3222  s_fdFrequencyList;
3224 
3226  inline llrp_u32v_t
3228  {
3229  return m_FrequencyList;
3230  }
3231 
3233  inline void
3235  llrp_u32v_t value)
3236  {
3237  m_FrequencyList = value;
3238  }
3239 
3240 
3241 
3242  protected:
3243  std::list<CParameter *> m_listCustom;
3244 
3245  public:
3247  inline std::list<CParameter *>::iterator
3249  {
3250  return m_listCustom.begin();
3251  }
3252 
3254  inline std::list<CParameter *>::iterator
3255  endCustom (void)
3256  {
3257  return m_listCustom.end();
3258  }
3259 
3261  inline void
3263  {
3264  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3265  }
3266 
3268  inline int
3270  {
3271  return (int) (m_listCustom.size());
3272  }
3273 
3274  EResultCode
3276  addCustom (
3277  CParameter * pValue);
3278 
3279 
3280 };
3281 
3282 
3309 class CImpinjGPIDebounceConfiguration : public CParameter
3310 {
3311  public:
3314 
3317 
3318  static const CFieldDescriptor * const
3319  s_apFieldDescriptorTable[];
3320 
3321  static const CTypeDescriptor
3322  s_typeDescriptor;
3323 
3324  void
3325  decodeFields (
3326  CDecoderStream * pDecoderStream);
3327 
3328  void
3329  assimilateSubParameters (
3330  CErrorDetails * pError);
3331 
3332  void
3333  encode (
3334  CEncoderStream * pEncoderStream) const;
3335 
3336 
3337  llrp_bool_t
3338  isAllowedIn (
3339  const CTypeDescriptor * pEnclosingElementType) const;
3340 
3341 
3342  static CElement *
3343  s_construct (void);
3344 
3345  static void
3346  s_decodeFields (
3347  CDecoderStream * pDecoderStream,
3348  CElement * pElement);
3350 
3351 
3352  protected:
3353  llrp_u16_t m_GPIPortNum;
3354 
3357  public:
3358  static const CFieldDescriptor
3359  s_fdGPIPortNum;
3361 
3363  inline llrp_u16_t
3365  {
3366  return m_GPIPortNum;
3367  }
3368 
3370  inline void
3372  llrp_u16_t value)
3373  {
3374  m_GPIPortNum = value;
3375  }
3376 
3377 
3378  protected:
3379  llrp_u32_t m_GPIDebounceTimerMSec;
3380 
3383  public:
3384  static const CFieldDescriptor
3385  s_fdGPIDebounceTimerMSec;
3387 
3389  inline llrp_u32_t
3391  {
3392  return m_GPIDebounceTimerMSec;
3393  }
3394 
3396  inline void
3398  llrp_u32_t value)
3399  {
3400  m_GPIDebounceTimerMSec = value;
3401  }
3402 
3403 
3404 
3405  protected:
3406  std::list<CParameter *> m_listCustom;
3407 
3408  public:
3410  inline std::list<CParameter *>::iterator
3412  {
3413  return m_listCustom.begin();
3414  }
3415 
3417  inline std::list<CParameter *>::iterator
3418  endCustom (void)
3419  {
3420  return m_listCustom.end();
3421  }
3422 
3424  inline void
3426  {
3427  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3428  }
3429 
3431  inline int
3433  {
3434  return (int) (m_listCustom.size());
3435  }
3436 
3437  EResultCode
3439  addCustom (
3440  CParameter * pValue);
3441 
3442 
3443 };
3444 
3445 
3470 class CImpinjReaderTemperature : public CParameter
3471 {
3472  public:
3473  CImpinjReaderTemperature (void);
3474  ~CImpinjReaderTemperature (void);
3475 
3478 
3479  static const CFieldDescriptor * const
3480  s_apFieldDescriptorTable[];
3481 
3482  static const CTypeDescriptor
3483  s_typeDescriptor;
3484 
3485  void
3486  decodeFields (
3487  CDecoderStream * pDecoderStream);
3488 
3489  void
3490  assimilateSubParameters (
3491  CErrorDetails * pError);
3492 
3493  void
3494  encode (
3495  CEncoderStream * pEncoderStream) const;
3496 
3497 
3498  llrp_bool_t
3499  isAllowedIn (
3500  const CTypeDescriptor * pEnclosingElementType) const;
3501 
3502 
3503  static CElement *
3504  s_construct (void);
3505 
3506  static void
3507  s_decodeFields (
3508  CDecoderStream * pDecoderStream,
3509  CElement * pElement);
3511 
3512 
3513  protected:
3514  llrp_s16_t m_Temperature;
3515 
3518  public:
3519  static const CFieldDescriptor
3520  s_fdTemperature;
3522 
3524  inline llrp_s16_t
3526  {
3527  return m_Temperature;
3528  }
3529 
3531  inline void
3533  llrp_s16_t value)
3534  {
3535  m_Temperature = value;
3536  }
3537 
3538 
3539 
3540  protected:
3541  std::list<CParameter *> m_listCustom;
3542 
3543  public:
3545  inline std::list<CParameter *>::iterator
3547  {
3548  return m_listCustom.begin();
3549  }
3550 
3552  inline std::list<CParameter *>::iterator
3553  endCustom (void)
3554  {
3555  return m_listCustom.end();
3556  }
3557 
3559  inline void
3561  {
3562  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3563  }
3564 
3566  inline int
3568  {
3569  return (int) (m_listCustom.size());
3570  }
3571 
3572  EResultCode
3574  addCustom (
3575  CParameter * pValue);
3576 
3577 
3578 };
3579 
3580 
3607 class CImpinjLinkMonitorConfiguration : public CParameter
3608 {
3609  public:
3612 
3615 
3616  static const CFieldDescriptor * const
3617  s_apFieldDescriptorTable[];
3618 
3619  static const CTypeDescriptor
3620  s_typeDescriptor;
3621 
3622  void
3623  decodeFields (
3624  CDecoderStream * pDecoderStream);
3625 
3626  void
3627  assimilateSubParameters (
3628  CErrorDetails * pError);
3629 
3630  void
3631  encode (
3632  CEncoderStream * pEncoderStream) const;
3633 
3634 
3635  llrp_bool_t
3636  isAllowedIn (
3637  const CTypeDescriptor * pEnclosingElementType) const;
3638 
3639 
3640  static CElement *
3641  s_construct (void);
3642 
3643  static void
3644  s_decodeFields (
3645  CDecoderStream * pDecoderStream,
3646  CElement * pElement);
3648 
3649 
3650  protected:
3651  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3652 
3655  public:
3656  static const CFieldDescriptor
3657  s_fdLinkMonitorMode;
3659 
3661  inline EImpinjLinkMonitorMode
3663  {
3664  return m_eLinkMonitorMode;
3665  }
3666 
3668  inline void
3670  EImpinjLinkMonitorMode value)
3671  {
3672  m_eLinkMonitorMode = value;
3673  }
3674 
3675 
3676  protected:
3677  llrp_u16_t m_LinkDownThreshold;
3678 
3681  public:
3682  static const CFieldDescriptor
3683  s_fdLinkDownThreshold;
3685 
3687  inline llrp_u16_t
3689  {
3690  return m_LinkDownThreshold;
3691  }
3692 
3694  inline void
3696  llrp_u16_t value)
3697  {
3698  m_LinkDownThreshold = value;
3699  }
3700 
3701 
3702 
3703  protected:
3704  std::list<CParameter *> m_listCustom;
3705 
3706  public:
3708  inline std::list<CParameter *>::iterator
3710  {
3711  return m_listCustom.begin();
3712  }
3713 
3715  inline std::list<CParameter *>::iterator
3716  endCustom (void)
3717  {
3718  return m_listCustom.end();
3719  }
3720 
3722  inline void
3724  {
3725  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3726  }
3727 
3729  inline int
3731  {
3732  return (int) (m_listCustom.size());
3733  }
3734 
3735  EResultCode
3737  addCustom (
3738  CParameter * pValue);
3739 
3740 
3741 };
3742 
3743 
3769 class CImpinjReportBufferConfiguration : public CParameter
3770 {
3771  public:
3774 
3777 
3778  static const CFieldDescriptor * const
3779  s_apFieldDescriptorTable[];
3780 
3781  static const CTypeDescriptor
3782  s_typeDescriptor;
3783 
3784  void
3785  decodeFields (
3786  CDecoderStream * pDecoderStream);
3787 
3788  void
3789  assimilateSubParameters (
3790  CErrorDetails * pError);
3791 
3792  void
3793  encode (
3794  CEncoderStream * pEncoderStream) const;
3795 
3796 
3797  llrp_bool_t
3798  isAllowedIn (
3799  const CTypeDescriptor * pEnclosingElementType) const;
3800 
3801 
3802  static CElement *
3803  s_construct (void);
3804 
3805  static void
3806  s_decodeFields (
3807  CDecoderStream * pDecoderStream,
3808  CElement * pElement);
3810 
3811 
3812  protected:
3813  EImpinjReportBufferMode m_eReportBufferMode;
3814 
3817  public:
3818  static const CFieldDescriptor
3819  s_fdReportBufferMode;
3821 
3823  inline EImpinjReportBufferMode
3825  {
3826  return m_eReportBufferMode;
3827  }
3828 
3830  inline void
3832  EImpinjReportBufferMode value)
3833  {
3834  m_eReportBufferMode = value;
3835  }
3836 
3837 
3838 
3839  protected:
3840  std::list<CParameter *> m_listCustom;
3841 
3842  public:
3844  inline std::list<CParameter *>::iterator
3846  {
3847  return m_listCustom.begin();
3848  }
3849 
3851  inline std::list<CParameter *>::iterator
3852  endCustom (void)
3853  {
3854  return m_listCustom.end();
3855  }
3856 
3858  inline void
3860  {
3861  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3862  }
3863 
3865  inline int
3867  {
3868  return (int) (m_listCustom.size());
3869  }
3870 
3871  EResultCode
3873  addCustom (
3874  CParameter * pValue);
3875 
3876 
3877 };
3878 
3879 
3908 class CImpinjAccessSpecConfiguration : public CParameter
3909 {
3910  public:
3913 
3916 
3917  static const CFieldDescriptor * const
3918  s_apFieldDescriptorTable[];
3919 
3920  static const CTypeDescriptor
3921  s_typeDescriptor;
3922 
3923  void
3924  decodeFields (
3925  CDecoderStream * pDecoderStream);
3926 
3927  void
3928  assimilateSubParameters (
3929  CErrorDetails * pError);
3930 
3931  void
3932  encode (
3933  CEncoderStream * pEncoderStream) const;
3934 
3935 
3936  llrp_bool_t
3937  isAllowedIn (
3938  const CTypeDescriptor * pEnclosingElementType) const;
3939 
3940 
3941  static CElement *
3942  s_construct (void);
3943 
3944  static void
3945  s_decodeFields (
3946  CDecoderStream * pDecoderStream,
3947  CElement * pElement);
3949 
3950 
3951 
3952  protected:
3953  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3954 
3955  public:
3959  {
3960  return m_pImpinjBlockWriteWordCount;
3961  }
3962 
3964  EResultCode
3965  setImpinjBlockWriteWordCount (
3966  CImpinjBlockWriteWordCount * pValue);
3967 
3968 
3969  protected:
3970  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3971 
3972  public:
3974  inline CImpinjOpSpecRetryCount *
3976  {
3977  return m_pImpinjOpSpecRetryCount;
3978  }
3979 
3981  EResultCode
3982  setImpinjOpSpecRetryCount (
3983  CImpinjOpSpecRetryCount * pValue);
3984 
3985 
3986  protected:
3987  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3988 
3989  public:
3991  inline CImpinjAccessSpecOrdering *
3993  {
3994  return m_pImpinjAccessSpecOrdering;
3995  }
3996 
3998  EResultCode
3999  setImpinjAccessSpecOrdering (
4000  CImpinjAccessSpecOrdering * pValue);
4001 
4002 
4003  protected:
4004  std::list<CParameter *> m_listCustom;
4005 
4006  public:
4008  inline std::list<CParameter *>::iterator
4010  {
4011  return m_listCustom.begin();
4012  }
4013 
4015  inline std::list<CParameter *>::iterator
4016  endCustom (void)
4017  {
4018  return m_listCustom.end();
4019  }
4020 
4022  inline void
4024  {
4025  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4026  }
4027 
4029  inline int
4031  {
4032  return (int) (m_listCustom.size());
4033  }
4034 
4035  EResultCode
4037  addCustom (
4038  CParameter * pValue);
4039 
4040 
4041 };
4042 
4043 
4067 class CImpinjBlockWriteWordCount : public CParameter
4068 {
4069  public:
4072 
4075 
4076  static const CFieldDescriptor * const
4077  s_apFieldDescriptorTable[];
4078 
4079  static const CTypeDescriptor
4080  s_typeDescriptor;
4081 
4082  void
4083  decodeFields (
4084  CDecoderStream * pDecoderStream);
4085 
4086  void
4087  assimilateSubParameters (
4088  CErrorDetails * pError);
4089 
4090  void
4091  encode (
4092  CEncoderStream * pEncoderStream) const;
4093 
4094 
4095  llrp_bool_t
4096  isAllowedIn (
4097  const CTypeDescriptor * pEnclosingElementType) const;
4098 
4099 
4100  static CElement *
4101  s_construct (void);
4102 
4103  static void
4104  s_decodeFields (
4105  CDecoderStream * pDecoderStream,
4106  CElement * pElement);
4108 
4109 
4110  protected:
4111  llrp_u16_t m_WordCount;
4112 
4115  public:
4116  static const CFieldDescriptor
4117  s_fdWordCount;
4119 
4121  inline llrp_u16_t
4123  {
4124  return m_WordCount;
4125  }
4126 
4128  inline void
4130  llrp_u16_t value)
4131  {
4132  m_WordCount = value;
4133  }
4134 
4135 
4136 
4137  protected:
4138  std::list<CParameter *> m_listCustom;
4139 
4140  public:
4142  inline std::list<CParameter *>::iterator
4144  {
4145  return m_listCustom.begin();
4146  }
4147 
4149  inline std::list<CParameter *>::iterator
4150  endCustom (void)
4151  {
4152  return m_listCustom.end();
4153  }
4154 
4156  inline void
4158  {
4159  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4160  }
4161 
4163  inline int
4165  {
4166  return (int) (m_listCustom.size());
4167  }
4168 
4169  EResultCode
4171  addCustom (
4172  CParameter * pValue);
4173 
4174 
4175 };
4176 
4177 
4207 class CImpinjBlockPermalock : public CParameter
4208 {
4209  public:
4210  CImpinjBlockPermalock (void);
4211  ~CImpinjBlockPermalock (void);
4212 
4215 
4216  static const CFieldDescriptor * const
4217  s_apFieldDescriptorTable[];
4218 
4219  static const CTypeDescriptor
4220  s_typeDescriptor;
4221 
4222  void
4223  decodeFields (
4224  CDecoderStream * pDecoderStream);
4225 
4226  void
4227  assimilateSubParameters (
4228  CErrorDetails * pError);
4229 
4230  void
4231  encode (
4232  CEncoderStream * pEncoderStream) const;
4233 
4234 
4235  llrp_bool_t
4236  isAllowedIn (
4237  const CTypeDescriptor * pEnclosingElementType) const;
4238 
4239 
4240  static CElement *
4241  s_construct (void);
4242 
4243  static void
4244  s_decodeFields (
4245  CDecoderStream * pDecoderStream,
4246  CElement * pElement);
4248 
4249 
4250  protected:
4251  llrp_u16_t m_OpSpecID;
4252 
4255  public:
4256  static const CFieldDescriptor
4257  s_fdOpSpecID;
4259 
4261  inline llrp_u16_t
4263  {
4264  return m_OpSpecID;
4265  }
4266 
4268  inline void
4270  llrp_u16_t value)
4271  {
4272  m_OpSpecID = value;
4273  }
4274 
4275 
4276  protected:
4277  llrp_u32_t m_AccessPassword;
4278 
4281  public:
4282  static const CFieldDescriptor
4283  s_fdAccessPassword;
4285 
4287  inline llrp_u32_t
4289  {
4290  return m_AccessPassword;
4291  }
4292 
4294  inline void
4296  llrp_u32_t value)
4297  {
4298  m_AccessPassword = value;
4299  }
4300 
4301 
4302  protected:
4303  llrp_u2_t m_MB;
4304 
4307  public:
4308  static const CFieldDescriptor
4309  s_fdMB;
4311 
4313  inline llrp_u2_t
4314  getMB (void)
4315  {
4316  return m_MB;
4317  }
4318 
4320  inline void
4322  llrp_u2_t value)
4323  {
4324  m_MB = value;
4325  }
4326 
4327 
4328  protected:
4329  llrp_u16_t m_BlockPointer;
4330 
4333  public:
4334  static const CFieldDescriptor
4335  s_fdBlockPointer;
4337 
4339  inline llrp_u16_t
4341  {
4342  return m_BlockPointer;
4343  }
4344 
4346  inline void
4348  llrp_u16_t value)
4349  {
4350  m_BlockPointer = value;
4351  }
4352 
4353 
4354  protected:
4355  llrp_u16v_t m_BlockMask;
4356 
4359  public:
4360  static const CFieldDescriptor
4361  s_fdBlockMask;
4363 
4365  inline llrp_u16v_t
4367  {
4368  return m_BlockMask;
4369  }
4370 
4372  inline void
4374  llrp_u16v_t value)
4375  {
4376  m_BlockMask = value;
4377  }
4378 
4379 
4380 
4381  protected:
4382  std::list<CParameter *> m_listCustom;
4383 
4384  public:
4386  inline std::list<CParameter *>::iterator
4388  {
4389  return m_listCustom.begin();
4390  }
4391 
4393  inline std::list<CParameter *>::iterator
4394  endCustom (void)
4395  {
4396  return m_listCustom.end();
4397  }
4398 
4400  inline void
4402  {
4403  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4404  }
4405 
4407  inline int
4409  {
4410  return (int) (m_listCustom.size());
4411  }
4412 
4413  EResultCode
4415  addCustom (
4416  CParameter * pValue);
4417 
4418 
4419 };
4420 
4421 
4447 class CImpinjBlockPermalockOpSpecResult : public CParameter
4448 {
4449  public:
4452 
4455 
4456  static const CFieldDescriptor * const
4457  s_apFieldDescriptorTable[];
4458 
4459  static const CTypeDescriptor
4460  s_typeDescriptor;
4461 
4462  void
4463  decodeFields (
4464  CDecoderStream * pDecoderStream);
4465 
4466  void
4467  assimilateSubParameters (
4468  CErrorDetails * pError);
4469 
4470  void
4471  encode (
4472  CEncoderStream * pEncoderStream) const;
4473 
4474 
4475  llrp_bool_t
4476  isAllowedIn (
4477  const CTypeDescriptor * pEnclosingElementType) const;
4478 
4479 
4480  static CElement *
4481  s_construct (void);
4482 
4483  static void
4484  s_decodeFields (
4485  CDecoderStream * pDecoderStream,
4486  CElement * pElement);
4488 
4489 
4490  protected:
4491  EImpinjBlockPermalockResultType m_eResult;
4492 
4495  public:
4496  static const CFieldDescriptor
4497  s_fdResult;
4499 
4501  inline EImpinjBlockPermalockResultType
4502  getResult (void)
4503  {
4504  return m_eResult;
4505  }
4506 
4508  inline void
4510  EImpinjBlockPermalockResultType value)
4511  {
4512  m_eResult = value;
4513  }
4514 
4515 
4516  protected:
4517  llrp_u16_t m_OpSpecID;
4518 
4521  public:
4522  static const CFieldDescriptor
4523  s_fdOpSpecID;
4525 
4527  inline llrp_u16_t
4529  {
4530  return m_OpSpecID;
4531  }
4532 
4534  inline void
4536  llrp_u16_t value)
4537  {
4538  m_OpSpecID = value;
4539  }
4540 
4541 
4542 
4543  protected:
4544  std::list<CParameter *> m_listCustom;
4545 
4546  public:
4548  inline std::list<CParameter *>::iterator
4550  {
4551  return m_listCustom.begin();
4552  }
4553 
4555  inline std::list<CParameter *>::iterator
4556  endCustom (void)
4557  {
4558  return m_listCustom.end();
4559  }
4560 
4562  inline void
4564  {
4565  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4566  }
4567 
4569  inline int
4571  {
4572  return (int) (m_listCustom.size());
4573  }
4574 
4575  EResultCode
4577  addCustom (
4578  CParameter * pValue);
4579 
4580 
4581 };
4582 
4583 
4613 class CImpinjGetBlockPermalockStatus : public CParameter
4614 {
4615  public:
4618 
4621 
4622  static const CFieldDescriptor * const
4623  s_apFieldDescriptorTable[];
4624 
4625  static const CTypeDescriptor
4626  s_typeDescriptor;
4627 
4628  void
4629  decodeFields (
4630  CDecoderStream * pDecoderStream);
4631 
4632  void
4633  assimilateSubParameters (
4634  CErrorDetails * pError);
4635 
4636  void
4637  encode (
4638  CEncoderStream * pEncoderStream) const;
4639 
4640 
4641  llrp_bool_t
4642  isAllowedIn (
4643  const CTypeDescriptor * pEnclosingElementType) const;
4644 
4645 
4646  static CElement *
4647  s_construct (void);
4648 
4649  static void
4650  s_decodeFields (
4651  CDecoderStream * pDecoderStream,
4652  CElement * pElement);
4654 
4655 
4656  protected:
4657  llrp_u16_t m_OpSpecID;
4658 
4661  public:
4662  static const CFieldDescriptor
4663  s_fdOpSpecID;
4665 
4667  inline llrp_u16_t
4669  {
4670  return m_OpSpecID;
4671  }
4672 
4674  inline void
4676  llrp_u16_t value)
4677  {
4678  m_OpSpecID = value;
4679  }
4680 
4681 
4682  protected:
4683  llrp_u32_t m_AccessPassword;
4684 
4687  public:
4688  static const CFieldDescriptor
4689  s_fdAccessPassword;
4691 
4693  inline llrp_u32_t
4695  {
4696  return m_AccessPassword;
4697  }
4698 
4700  inline void
4702  llrp_u32_t value)
4703  {
4704  m_AccessPassword = value;
4705  }
4706 
4707 
4708  protected:
4709  llrp_u2_t m_MB;
4710 
4713  public:
4714  static const CFieldDescriptor
4715  s_fdMB;
4717 
4719  inline llrp_u2_t
4720  getMB (void)
4721  {
4722  return m_MB;
4723  }
4724 
4726  inline void
4728  llrp_u2_t value)
4729  {
4730  m_MB = value;
4731  }
4732 
4733 
4734  protected:
4735  llrp_u16_t m_BlockPointer;
4736 
4739  public:
4740  static const CFieldDescriptor
4741  s_fdBlockPointer;
4743 
4745  inline llrp_u16_t
4747  {
4748  return m_BlockPointer;
4749  }
4750 
4752  inline void
4754  llrp_u16_t value)
4755  {
4756  m_BlockPointer = value;
4757  }
4758 
4759 
4760  protected:
4761  llrp_u16_t m_BlockRange;
4762 
4765  public:
4766  static const CFieldDescriptor
4767  s_fdBlockRange;
4769 
4771  inline llrp_u16_t
4773  {
4774  return m_BlockRange;
4775  }
4776 
4778  inline void
4780  llrp_u16_t value)
4781  {
4782  m_BlockRange = value;
4783  }
4784 
4785 
4786 
4787  protected:
4788  std::list<CParameter *> m_listCustom;
4789 
4790  public:
4792  inline std::list<CParameter *>::iterator
4794  {
4795  return m_listCustom.begin();
4796  }
4797 
4799  inline std::list<CParameter *>::iterator
4800  endCustom (void)
4801  {
4802  return m_listCustom.end();
4803  }
4804 
4806  inline void
4808  {
4809  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4810  }
4811 
4813  inline int
4815  {
4816  return (int) (m_listCustom.size());
4817  }
4818 
4819  EResultCode
4821  addCustom (
4822  CParameter * pValue);
4823 
4824 
4825 };
4826 
4827 
4854 class CImpinjGetBlockPermalockStatusOpSpecResult : public CParameter
4855 {
4856  public:
4859 
4862 
4863  static const CFieldDescriptor * const
4864  s_apFieldDescriptorTable[];
4865 
4866  static const CTypeDescriptor
4867  s_typeDescriptor;
4868 
4869  void
4870  decodeFields (
4871  CDecoderStream * pDecoderStream);
4872 
4873  void
4874  assimilateSubParameters (
4875  CErrorDetails * pError);
4876 
4877  void
4878  encode (
4879  CEncoderStream * pEncoderStream) const;
4880 
4881 
4882  llrp_bool_t
4883  isAllowedIn (
4884  const CTypeDescriptor * pEnclosingElementType) const;
4885 
4886 
4887  static CElement *
4888  s_construct (void);
4889 
4890  static void
4891  s_decodeFields (
4892  CDecoderStream * pDecoderStream,
4893  CElement * pElement);
4895 
4896 
4897  protected:
4898  EImpinjGetBlockPermalockStatusResultType m_eResult;
4899 
4902  public:
4903  static const CFieldDescriptor
4904  s_fdResult;
4906 
4908  inline EImpinjGetBlockPermalockStatusResultType
4909  getResult (void)
4910  {
4911  return m_eResult;
4912  }
4913 
4915  inline void
4917  EImpinjGetBlockPermalockStatusResultType value)
4918  {
4919  m_eResult = value;
4920  }
4921 
4922 
4923  protected:
4924  llrp_u16_t m_OpSpecID;
4925 
4928  public:
4929  static const CFieldDescriptor
4930  s_fdOpSpecID;
4932 
4934  inline llrp_u16_t
4936  {
4937  return m_OpSpecID;
4938  }
4939 
4941  inline void
4943  llrp_u16_t value)
4944  {
4945  m_OpSpecID = value;
4946  }
4947 
4948 
4949  protected:
4950  llrp_u16v_t m_PermalockStatus;
4951 
4954  public:
4955  static const CFieldDescriptor
4956  s_fdPermalockStatus;
4958 
4960  inline llrp_u16v_t
4962  {
4963  return m_PermalockStatus;
4964  }
4965 
4967  inline void
4969  llrp_u16v_t value)
4970  {
4971  m_PermalockStatus = value;
4972  }
4973 
4974 
4975 
4976  protected:
4977  std::list<CParameter *> m_listCustom;
4978 
4979  public:
4981  inline std::list<CParameter *>::iterator
4983  {
4984  return m_listCustom.begin();
4985  }
4986 
4988  inline std::list<CParameter *>::iterator
4989  endCustom (void)
4990  {
4991  return m_listCustom.end();
4992  }
4993 
4995  inline void
4997  {
4998  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4999  }
5000 
5002  inline int
5004  {
5005  return (int) (m_listCustom.size());
5006  }
5007 
5008  EResultCode
5010  addCustom (
5011  CParameter * pValue);
5012 
5013 
5014 };
5015 
5016 
5046 class CImpinjSetQTConfig : public CParameter
5047 {
5048  public:
5049  CImpinjSetQTConfig (void);
5050  ~CImpinjSetQTConfig (void);
5051 
5054 
5055  static const CFieldDescriptor * const
5056  s_apFieldDescriptorTable[];
5057 
5058  static const CTypeDescriptor
5059  s_typeDescriptor;
5060 
5061  void
5062  decodeFields (
5063  CDecoderStream * pDecoderStream);
5064 
5065  void
5066  assimilateSubParameters (
5067  CErrorDetails * pError);
5068 
5069  void
5070  encode (
5071  CEncoderStream * pEncoderStream) const;
5072 
5073 
5074  llrp_bool_t
5075  isAllowedIn (
5076  const CTypeDescriptor * pEnclosingElementType) const;
5077 
5078 
5079  static CElement *
5080  s_construct (void);
5081 
5082  static void
5083  s_decodeFields (
5084  CDecoderStream * pDecoderStream,
5085  CElement * pElement);
5087 
5088 
5089  protected:
5090  llrp_u16_t m_OpSpecID;
5091 
5094  public:
5095  static const CFieldDescriptor
5096  s_fdOpSpecID;
5098 
5100  inline llrp_u16_t
5102  {
5103  return m_OpSpecID;
5104  }
5105 
5107  inline void
5109  llrp_u16_t value)
5110  {
5111  m_OpSpecID = value;
5112  }
5113 
5114 
5115  protected:
5116  llrp_u32_t m_AccessPassword;
5117 
5120  public:
5121  static const CFieldDescriptor
5122  s_fdAccessPassword;
5124 
5126  inline llrp_u32_t
5128  {
5129  return m_AccessPassword;
5130  }
5131 
5133  inline void
5135  llrp_u32_t value)
5136  {
5137  m_AccessPassword = value;
5138  }
5139 
5140 
5141  protected:
5142  EImpinjQTDataProfile m_eDataProfile;
5143 
5146  public:
5147  static const CFieldDescriptor
5148  s_fdDataProfile;
5150 
5152  inline EImpinjQTDataProfile
5154  {
5155  return m_eDataProfile;
5156  }
5157 
5159  inline void
5161  EImpinjQTDataProfile value)
5162  {
5163  m_eDataProfile = value;
5164  }
5165 
5166 
5167  protected:
5168  EImpinjQTAccessRange m_eAccessRange;
5169 
5172  public:
5173  static const CFieldDescriptor
5174  s_fdAccessRange;
5176 
5178  inline EImpinjQTAccessRange
5180  {
5181  return m_eAccessRange;
5182  }
5183 
5185  inline void
5187  EImpinjQTAccessRange value)
5188  {
5189  m_eAccessRange = value;
5190  }
5191 
5192 
5193  protected:
5194  EImpinjQTPersistence m_ePersistence;
5195 
5198  public:
5199  static const CFieldDescriptor
5200  s_fdPersistence;
5202 
5204  inline EImpinjQTPersistence
5206  {
5207  return m_ePersistence;
5208  }
5209 
5211  inline void
5213  EImpinjQTPersistence value)
5214  {
5215  m_ePersistence = value;
5216  }
5217 
5218 
5219 
5220  protected:
5221  std::list<CParameter *> m_listCustom;
5222 
5223  public:
5225  inline std::list<CParameter *>::iterator
5227  {
5228  return m_listCustom.begin();
5229  }
5230 
5232  inline std::list<CParameter *>::iterator
5233  endCustom (void)
5234  {
5235  return m_listCustom.end();
5236  }
5237 
5239  inline void
5241  {
5242  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5243  }
5244 
5246  inline int
5248  {
5249  return (int) (m_listCustom.size());
5250  }
5251 
5252  EResultCode
5254  addCustom (
5255  CParameter * pValue);
5256 
5257 
5258 };
5259 
5260 
5286 class CImpinjSetQTConfigOpSpecResult : public CParameter
5287 {
5288  public:
5291 
5294 
5295  static const CFieldDescriptor * const
5296  s_apFieldDescriptorTable[];
5297 
5298  static const CTypeDescriptor
5299  s_typeDescriptor;
5300 
5301  void
5302  decodeFields (
5303  CDecoderStream * pDecoderStream);
5304 
5305  void
5306  assimilateSubParameters (
5307  CErrorDetails * pError);
5308 
5309  void
5310  encode (
5311  CEncoderStream * pEncoderStream) const;
5312 
5313 
5314  llrp_bool_t
5315  isAllowedIn (
5316  const CTypeDescriptor * pEnclosingElementType) const;
5317 
5318 
5319  static CElement *
5320  s_construct (void);
5321 
5322  static void
5323  s_decodeFields (
5324  CDecoderStream * pDecoderStream,
5325  CElement * pElement);
5327 
5328 
5329  protected:
5330  EImpinjSetQTConfigResultType m_eResult;
5331 
5334  public:
5335  static const CFieldDescriptor
5336  s_fdResult;
5338 
5340  inline EImpinjSetQTConfigResultType
5341  getResult (void)
5342  {
5343  return m_eResult;
5344  }
5345 
5347  inline void
5349  EImpinjSetQTConfigResultType value)
5350  {
5351  m_eResult = value;
5352  }
5353 
5354 
5355  protected:
5356  llrp_u16_t m_OpSpecID;
5357 
5360  public:
5361  static const CFieldDescriptor
5362  s_fdOpSpecID;
5364 
5366  inline llrp_u16_t
5368  {
5369  return m_OpSpecID;
5370  }
5371 
5373  inline void
5375  llrp_u16_t value)
5376  {
5377  m_OpSpecID = value;
5378  }
5379 
5380 
5381 
5382  protected:
5383  std::list<CParameter *> m_listCustom;
5384 
5385  public:
5387  inline std::list<CParameter *>::iterator
5389  {
5390  return m_listCustom.begin();
5391  }
5392 
5394  inline std::list<CParameter *>::iterator
5395  endCustom (void)
5396  {
5397  return m_listCustom.end();
5398  }
5399 
5401  inline void
5403  {
5404  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5405  }
5406 
5408  inline int
5410  {
5411  return (int) (m_listCustom.size());
5412  }
5413 
5414  EResultCode
5416  addCustom (
5417  CParameter * pValue);
5418 
5419 
5420 };
5421 
5422 
5448 class CImpinjGetQTConfig : public CParameter
5449 {
5450  public:
5451  CImpinjGetQTConfig (void);
5452  ~CImpinjGetQTConfig (void);
5453 
5456 
5457  static const CFieldDescriptor * const
5458  s_apFieldDescriptorTable[];
5459 
5460  static const CTypeDescriptor
5461  s_typeDescriptor;
5462 
5463  void
5464  decodeFields (
5465  CDecoderStream * pDecoderStream);
5466 
5467  void
5468  assimilateSubParameters (
5469  CErrorDetails * pError);
5470 
5471  void
5472  encode (
5473  CEncoderStream * pEncoderStream) const;
5474 
5475 
5476  llrp_bool_t
5477  isAllowedIn (
5478  const CTypeDescriptor * pEnclosingElementType) const;
5479 
5480 
5481  static CElement *
5482  s_construct (void);
5483 
5484  static void
5485  s_decodeFields (
5486  CDecoderStream * pDecoderStream,
5487  CElement * pElement);
5489 
5490 
5491  protected:
5492  llrp_u16_t m_OpSpecID;
5493 
5496  public:
5497  static const CFieldDescriptor
5498  s_fdOpSpecID;
5500 
5502  inline llrp_u16_t
5504  {
5505  return m_OpSpecID;
5506  }
5507 
5509  inline void
5511  llrp_u16_t value)
5512  {
5513  m_OpSpecID = value;
5514  }
5515 
5516 
5517  protected:
5518  llrp_u32_t m_AccessPassword;
5519 
5522  public:
5523  static const CFieldDescriptor
5524  s_fdAccessPassword;
5526 
5528  inline llrp_u32_t
5530  {
5531  return m_AccessPassword;
5532  }
5533 
5535  inline void
5537  llrp_u32_t value)
5538  {
5539  m_AccessPassword = value;
5540  }
5541 
5542 
5543 
5544  protected:
5545  std::list<CParameter *> m_listCustom;
5546 
5547  public:
5549  inline std::list<CParameter *>::iterator
5551  {
5552  return m_listCustom.begin();
5553  }
5554 
5556  inline std::list<CParameter *>::iterator
5557  endCustom (void)
5558  {
5559  return m_listCustom.end();
5560  }
5561 
5563  inline void
5565  {
5566  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5567  }
5568 
5570  inline int
5572  {
5573  return (int) (m_listCustom.size());
5574  }
5575 
5576  EResultCode
5578  addCustom (
5579  CParameter * pValue);
5580 
5581 
5582 };
5583 
5584 
5613 class CImpinjGetQTConfigOpSpecResult : public CParameter
5614 {
5615  public:
5618 
5621 
5622  static const CFieldDescriptor * const
5623  s_apFieldDescriptorTable[];
5624 
5625  static const CTypeDescriptor
5626  s_typeDescriptor;
5627 
5628  void
5629  decodeFields (
5630  CDecoderStream * pDecoderStream);
5631 
5632  void
5633  assimilateSubParameters (
5634  CErrorDetails * pError);
5635 
5636  void
5637  encode (
5638  CEncoderStream * pEncoderStream) const;
5639 
5640 
5641  llrp_bool_t
5642  isAllowedIn (
5643  const CTypeDescriptor * pEnclosingElementType) const;
5644 
5645 
5646  static CElement *
5647  s_construct (void);
5648 
5649  static void
5650  s_decodeFields (
5651  CDecoderStream * pDecoderStream,
5652  CElement * pElement);
5654 
5655 
5656  protected:
5657  EImpinjGetQTConfigResultType m_eResult;
5658 
5661  public:
5662  static const CFieldDescriptor
5663  s_fdResult;
5665 
5667  inline EImpinjGetQTConfigResultType
5668  getResult (void)
5669  {
5670  return m_eResult;
5671  }
5672 
5674  inline void
5676  EImpinjGetQTConfigResultType value)
5677  {
5678  m_eResult = value;
5679  }
5680 
5681 
5682  protected:
5683  llrp_u16_t m_OpSpecID;
5684 
5687  public:
5688  static const CFieldDescriptor
5689  s_fdOpSpecID;
5691 
5693  inline llrp_u16_t
5695  {
5696  return m_OpSpecID;
5697  }
5698 
5700  inline void
5702  llrp_u16_t value)
5703  {
5704  m_OpSpecID = value;
5705  }
5706 
5707 
5708  protected:
5709  EImpinjQTDataProfile m_eDataProfile;
5710 
5713  public:
5714  static const CFieldDescriptor
5715  s_fdDataProfile;
5717 
5719  inline EImpinjQTDataProfile
5721  {
5722  return m_eDataProfile;
5723  }
5724 
5726  inline void
5728  EImpinjQTDataProfile value)
5729  {
5730  m_eDataProfile = value;
5731  }
5732 
5733 
5734  protected:
5735  EImpinjQTAccessRange m_eAccessRange;
5736 
5739  public:
5740  static const CFieldDescriptor
5741  s_fdAccessRange;
5743 
5745  inline EImpinjQTAccessRange
5747  {
5748  return m_eAccessRange;
5749  }
5750 
5752  inline void
5754  EImpinjQTAccessRange value)
5755  {
5756  m_eAccessRange = value;
5757  }
5758 
5759 
5760 
5761  protected:
5762  std::list<CParameter *> m_listCustom;
5763 
5764  public:
5766  inline std::list<CParameter *>::iterator
5768  {
5769  return m_listCustom.begin();
5770  }
5771 
5773  inline std::list<CParameter *>::iterator
5774  endCustom (void)
5775  {
5776  return m_listCustom.end();
5777  }
5778 
5780  inline void
5782  {
5783  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5784  }
5785 
5787  inline int
5789  {
5790  return (int) (m_listCustom.size());
5791  }
5792 
5793  EResultCode
5795  addCustom (
5796  CParameter * pValue);
5797 
5798 
5799 };
5800 
5801 
5832 class CImpinjTagReportContentSelector : public CParameter
5833 {
5834  public:
5837 
5840 
5841  static const CFieldDescriptor * const
5842  s_apFieldDescriptorTable[];
5843 
5844  static const CTypeDescriptor
5845  s_typeDescriptor;
5846 
5847  void
5848  decodeFields (
5849  CDecoderStream * pDecoderStream);
5850 
5851  void
5852  assimilateSubParameters (
5853  CErrorDetails * pError);
5854 
5855  void
5856  encode (
5857  CEncoderStream * pEncoderStream) const;
5858 
5859 
5860  llrp_bool_t
5861  isAllowedIn (
5862  const CTypeDescriptor * pEnclosingElementType) const;
5863 
5864 
5865  static CElement *
5866  s_construct (void);
5867 
5868  static void
5869  s_decodeFields (
5870  CDecoderStream * pDecoderStream,
5871  CElement * pElement);
5873 
5874 
5875 
5876  protected:
5877  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5878 
5879  public:
5883  {
5884  return m_pImpinjEnableSerializedTID;
5885  }
5886 
5888  EResultCode
5889  setImpinjEnableSerializedTID (
5890  CImpinjEnableSerializedTID * pValue);
5891 
5892 
5893  protected:
5894  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5895 
5896  public:
5898  inline CImpinjEnableRFPhaseAngle *
5900  {
5901  return m_pImpinjEnableRFPhaseAngle;
5902  }
5903 
5905  EResultCode
5906  setImpinjEnableRFPhaseAngle (
5907  CImpinjEnableRFPhaseAngle * pValue);
5908 
5909 
5910  protected:
5911  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5912 
5913  public:
5915  inline CImpinjEnablePeakRSSI *
5917  {
5918  return m_pImpinjEnablePeakRSSI;
5919  }
5920 
5922  EResultCode
5923  setImpinjEnablePeakRSSI (
5924  CImpinjEnablePeakRSSI * pValue);
5925 
5926 
5927  protected:
5928  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5929 
5930  public:
5934  {
5935  return m_pImpinjEnableGPSCoordinates;
5936  }
5937 
5939  EResultCode
5940  setImpinjEnableGPSCoordinates (
5941  CImpinjEnableGPSCoordinates * pValue);
5942 
5943 
5944  protected:
5945  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5946 
5947  public:
5951  {
5952  return m_pImpinjEnableOptimizedRead;
5953  }
5954 
5956  EResultCode
5957  setImpinjEnableOptimizedRead (
5958  CImpinjEnableOptimizedRead * pValue);
5959 
5960 
5961  protected:
5962  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5963 
5964  public:
5968  {
5969  return m_pImpinjEnableRFDopplerFrequency;
5970  }
5971 
5973  EResultCode
5974  setImpinjEnableRFDopplerFrequency (
5976 
5977 
5978  protected:
5979  CImpinjEnableTxPower * m_pImpinjEnableTxPower;
5980 
5981  public:
5983  inline CImpinjEnableTxPower *
5985  {
5986  return m_pImpinjEnableTxPower;
5987  }
5988 
5990  EResultCode
5991  setImpinjEnableTxPower (
5992  CImpinjEnableTxPower * pValue);
5993 
5994 
5995  protected:
5996  std::list<CParameter *> m_listCustom;
5997 
5998  public:
6000  inline std::list<CParameter *>::iterator
6002  {
6003  return m_listCustom.begin();
6004  }
6005 
6007  inline std::list<CParameter *>::iterator
6008  endCustom (void)
6009  {
6010  return m_listCustom.end();
6011  }
6012 
6014  inline void
6016  {
6017  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6018  }
6019 
6021  inline int
6023  {
6024  return (int) (m_listCustom.size());
6025  }
6026 
6027  EResultCode
6029  addCustom (
6030  CParameter * pValue);
6031 
6032 
6033 };
6034 
6035 
6059 class CImpinjEnableSerializedTID : public CParameter
6060 {
6061  public:
6064 
6067 
6068  static const CFieldDescriptor * const
6069  s_apFieldDescriptorTable[];
6070 
6071  static const CTypeDescriptor
6072  s_typeDescriptor;
6073 
6074  void
6075  decodeFields (
6076  CDecoderStream * pDecoderStream);
6077 
6078  void
6079  assimilateSubParameters (
6080  CErrorDetails * pError);
6081 
6082  void
6083  encode (
6084  CEncoderStream * pEncoderStream) const;
6085 
6086 
6087  llrp_bool_t
6088  isAllowedIn (
6089  const CTypeDescriptor * pEnclosingElementType) const;
6090 
6091 
6092  static CElement *
6093  s_construct (void);
6094 
6095  static void
6096  s_decodeFields (
6097  CDecoderStream * pDecoderStream,
6098  CElement * pElement);
6100 
6101 
6102  protected:
6103  EImpinjSerializedTIDMode m_eSerializedTIDMode;
6104 
6107  public:
6108  static const CFieldDescriptor
6109  s_fdSerializedTIDMode;
6111 
6113  inline EImpinjSerializedTIDMode
6115  {
6116  return m_eSerializedTIDMode;
6117  }
6118 
6120  inline void
6122  EImpinjSerializedTIDMode value)
6123  {
6124  m_eSerializedTIDMode = value;
6125  }
6126 
6127 
6128 
6129  protected:
6130  std::list<CParameter *> m_listCustom;
6131 
6132  public:
6134  inline std::list<CParameter *>::iterator
6136  {
6137  return m_listCustom.begin();
6138  }
6139 
6141  inline std::list<CParameter *>::iterator
6142  endCustom (void)
6143  {
6144  return m_listCustom.end();
6145  }
6146 
6148  inline void
6150  {
6151  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6152  }
6153 
6155  inline int
6157  {
6158  return (int) (m_listCustom.size());
6159  }
6160 
6161  EResultCode
6163  addCustom (
6164  CParameter * pValue);
6165 
6166 
6167 };
6168 
6169 
6193 class CImpinjEnableRFPhaseAngle : public CParameter
6194 {
6195  public:
6197  ~CImpinjEnableRFPhaseAngle (void);
6198 
6201 
6202  static const CFieldDescriptor * const
6203  s_apFieldDescriptorTable[];
6204 
6205  static const CTypeDescriptor
6206  s_typeDescriptor;
6207 
6208  void
6209  decodeFields (
6210  CDecoderStream * pDecoderStream);
6211 
6212  void
6213  assimilateSubParameters (
6214  CErrorDetails * pError);
6215 
6216  void
6217  encode (
6218  CEncoderStream * pEncoderStream) const;
6219 
6220 
6221  llrp_bool_t
6222  isAllowedIn (
6223  const CTypeDescriptor * pEnclosingElementType) const;
6224 
6225 
6226  static CElement *
6227  s_construct (void);
6228 
6229  static void
6230  s_decodeFields (
6231  CDecoderStream * pDecoderStream,
6232  CElement * pElement);
6234 
6235 
6236  protected:
6237  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
6238 
6241  public:
6242  static const CFieldDescriptor
6243  s_fdRFPhaseAngleMode;
6245 
6247  inline EImpinjRFPhaseAngleMode
6249  {
6250  return m_eRFPhaseAngleMode;
6251  }
6252 
6254  inline void
6256  EImpinjRFPhaseAngleMode value)
6257  {
6258  m_eRFPhaseAngleMode = value;
6259  }
6260 
6261 
6262 
6263  protected:
6264  std::list<CParameter *> m_listCustom;
6265 
6266  public:
6268  inline std::list<CParameter *>::iterator
6270  {
6271  return m_listCustom.begin();
6272  }
6273 
6275  inline std::list<CParameter *>::iterator
6276  endCustom (void)
6277  {
6278  return m_listCustom.end();
6279  }
6280 
6282  inline void
6284  {
6285  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6286  }
6287 
6289  inline int
6291  {
6292  return (int) (m_listCustom.size());
6293  }
6294 
6295  EResultCode
6297  addCustom (
6298  CParameter * pValue);
6299 
6300 
6301 };
6302 
6303 
6327 class CImpinjEnablePeakRSSI : public CParameter
6328 {
6329  public:
6330  CImpinjEnablePeakRSSI (void);
6331  ~CImpinjEnablePeakRSSI (void);
6332 
6335 
6336  static const CFieldDescriptor * const
6337  s_apFieldDescriptorTable[];
6338 
6339  static const CTypeDescriptor
6340  s_typeDescriptor;
6341 
6342  void
6343  decodeFields (
6344  CDecoderStream * pDecoderStream);
6345 
6346  void
6347  assimilateSubParameters (
6348  CErrorDetails * pError);
6349 
6350  void
6351  encode (
6352  CEncoderStream * pEncoderStream) const;
6353 
6354 
6355  llrp_bool_t
6356  isAllowedIn (
6357  const CTypeDescriptor * pEnclosingElementType) const;
6358 
6359 
6360  static CElement *
6361  s_construct (void);
6362 
6363  static void
6364  s_decodeFields (
6365  CDecoderStream * pDecoderStream,
6366  CElement * pElement);
6368 
6369 
6370  protected:
6371  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6372 
6375  public:
6376  static const CFieldDescriptor
6377  s_fdPeakRSSIMode;
6379 
6381  inline EImpinjPeakRSSIMode
6383  {
6384  return m_ePeakRSSIMode;
6385  }
6386 
6388  inline void
6390  EImpinjPeakRSSIMode value)
6391  {
6392  m_ePeakRSSIMode = value;
6393  }
6394 
6395 
6396 
6397  protected:
6398  std::list<CParameter *> m_listCustom;
6399 
6400  public:
6402  inline std::list<CParameter *>::iterator
6404  {
6405  return m_listCustom.begin();
6406  }
6407 
6409  inline std::list<CParameter *>::iterator
6410  endCustom (void)
6411  {
6412  return m_listCustom.end();
6413  }
6414 
6416  inline void
6418  {
6419  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6420  }
6421 
6423  inline int
6425  {
6426  return (int) (m_listCustom.size());
6427  }
6428 
6429  EResultCode
6431  addCustom (
6432  CParameter * pValue);
6433 
6434 
6435 };
6436 
6437 
6461 class CImpinjEnableGPSCoordinates : public CParameter
6462 {
6463  public:
6466 
6469 
6470  static const CFieldDescriptor * const
6471  s_apFieldDescriptorTable[];
6472 
6473  static const CTypeDescriptor
6474  s_typeDescriptor;
6475 
6476  void
6477  decodeFields (
6478  CDecoderStream * pDecoderStream);
6479 
6480  void
6481  assimilateSubParameters (
6482  CErrorDetails * pError);
6483 
6484  void
6485  encode (
6486  CEncoderStream * pEncoderStream) const;
6487 
6488 
6489  llrp_bool_t
6490  isAllowedIn (
6491  const CTypeDescriptor * pEnclosingElementType) const;
6492 
6493 
6494  static CElement *
6495  s_construct (void);
6496 
6497  static void
6498  s_decodeFields (
6499  CDecoderStream * pDecoderStream,
6500  CElement * pElement);
6502 
6503 
6504  protected:
6505  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6506 
6509  public:
6510  static const CFieldDescriptor
6511  s_fdGPSCoordinatesMode;
6513 
6515  inline EImpinjGPSCoordinatesMode
6517  {
6518  return m_eGPSCoordinatesMode;
6519  }
6520 
6522  inline void
6524  EImpinjGPSCoordinatesMode value)
6525  {
6526  m_eGPSCoordinatesMode = value;
6527  }
6528 
6529 
6530 
6531  protected:
6532  std::list<CParameter *> m_listCustom;
6533 
6534  public:
6536  inline std::list<CParameter *>::iterator
6538  {
6539  return m_listCustom.begin();
6540  }
6541 
6543  inline std::list<CParameter *>::iterator
6544  endCustom (void)
6545  {
6546  return m_listCustom.end();
6547  }
6548 
6550  inline void
6552  {
6553  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6554  }
6555 
6557  inline int
6559  {
6560  return (int) (m_listCustom.size());
6561  }
6562 
6563  EResultCode
6565  addCustom (
6566  CParameter * pValue);
6567 
6568 
6569 };
6570 
6571 
6597 class CImpinjSerializedTID : public CParameter
6598 {
6599  public:
6600  CImpinjSerializedTID (void);
6601  ~CImpinjSerializedTID (void);
6602 
6605 
6606  static const CFieldDescriptor * const
6607  s_apFieldDescriptorTable[];
6608 
6609  static const CTypeDescriptor
6610  s_typeDescriptor;
6611 
6612  void
6613  decodeFields (
6614  CDecoderStream * pDecoderStream);
6615 
6616  void
6617  assimilateSubParameters (
6618  CErrorDetails * pError);
6619 
6620  void
6621  encode (
6622  CEncoderStream * pEncoderStream) const;
6623 
6624 
6625  llrp_bool_t
6626  isAllowedIn (
6627  const CTypeDescriptor * pEnclosingElementType) const;
6628 
6629 
6630  static CElement *
6631  s_construct (void);
6632 
6633  static void
6634  s_decodeFields (
6635  CDecoderStream * pDecoderStream,
6636  CElement * pElement);
6638 
6639 
6640  protected:
6641  llrp_u16v_t m_TID;
6642 
6645  public:
6646  static const CFieldDescriptor
6647  s_fdTID;
6649 
6651  inline llrp_u16v_t
6652  getTID (void)
6653  {
6654  return m_TID;
6655  }
6656 
6658  inline void
6660  llrp_u16v_t value)
6661  {
6662  m_TID = value;
6663  }
6664 
6665 
6666 
6667  protected:
6668  CImpinjTIDParity * m_pImpinjTIDParity;
6669 
6670  public:
6672  inline CImpinjTIDParity *
6674  {
6675  return m_pImpinjTIDParity;
6676  }
6677 
6679  EResultCode
6680  setImpinjTIDParity (
6681  CImpinjTIDParity * pValue);
6682 
6683 
6684  protected:
6685  std::list<CParameter *> m_listCustom;
6686 
6687  public:
6689  inline std::list<CParameter *>::iterator
6691  {
6692  return m_listCustom.begin();
6693  }
6694 
6696  inline std::list<CParameter *>::iterator
6697  endCustom (void)
6698  {
6699  return m_listCustom.end();
6700  }
6701 
6703  inline void
6705  {
6706  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6707  }
6708 
6710  inline int
6712  {
6713  return (int) (m_listCustom.size());
6714  }
6715 
6716  EResultCode
6718  addCustom (
6719  CParameter * pValue);
6720 
6721 
6722 };
6723 
6724 
6749 class CImpinjRFPhaseAngle : public CParameter
6750 {
6751  public:
6752  CImpinjRFPhaseAngle (void);
6753  ~CImpinjRFPhaseAngle (void);
6754 
6757 
6758  static const CFieldDescriptor * const
6759  s_apFieldDescriptorTable[];
6760 
6761  static const CTypeDescriptor
6762  s_typeDescriptor;
6763 
6764  void
6765  decodeFields (
6766  CDecoderStream * pDecoderStream);
6767 
6768  void
6769  assimilateSubParameters (
6770  CErrorDetails * pError);
6771 
6772  void
6773  encode (
6774  CEncoderStream * pEncoderStream) const;
6775 
6776 
6777  llrp_bool_t
6778  isAllowedIn (
6779  const CTypeDescriptor * pEnclosingElementType) const;
6780 
6781 
6782  static CElement *
6783  s_construct (void);
6784 
6785  static void
6786  s_decodeFields (
6787  CDecoderStream * pDecoderStream,
6788  CElement * pElement);
6790 
6791 
6792  protected:
6793  llrp_u16_t m_PhaseAngle;
6794 
6797  public:
6798  static const CFieldDescriptor
6799  s_fdPhaseAngle;
6801 
6803  inline llrp_u16_t
6805  {
6806  return m_PhaseAngle;
6807  }
6808 
6810  inline void
6812  llrp_u16_t value)
6813  {
6814  m_PhaseAngle = value;
6815  }
6816 
6817 
6818 
6819  protected:
6820  std::list<CParameter *> m_listCustom;
6821 
6822  public:
6824  inline std::list<CParameter *>::iterator
6826  {
6827  return m_listCustom.begin();
6828  }
6829 
6831  inline std::list<CParameter *>::iterator
6832  endCustom (void)
6833  {
6834  return m_listCustom.end();
6835  }
6836 
6838  inline void
6840  {
6841  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6842  }
6843 
6845  inline int
6847  {
6848  return (int) (m_listCustom.size());
6849  }
6850 
6851  EResultCode
6853  addCustom (
6854  CParameter * pValue);
6855 
6856 
6857 };
6858 
6859 
6884 class CImpinjPeakRSSI : public CParameter
6885 {
6886  public:
6887  CImpinjPeakRSSI (void);
6888  ~CImpinjPeakRSSI (void);
6889 
6892 
6893  static const CFieldDescriptor * const
6894  s_apFieldDescriptorTable[];
6895 
6896  static const CTypeDescriptor
6897  s_typeDescriptor;
6898 
6899  void
6900  decodeFields (
6901  CDecoderStream * pDecoderStream);
6902 
6903  void
6904  assimilateSubParameters (
6905  CErrorDetails * pError);
6906 
6907  void
6908  encode (
6909  CEncoderStream * pEncoderStream) const;
6910 
6911 
6912  llrp_bool_t
6913  isAllowedIn (
6914  const CTypeDescriptor * pEnclosingElementType) const;
6915 
6916 
6917  static CElement *
6918  s_construct (void);
6919 
6920  static void
6921  s_decodeFields (
6922  CDecoderStream * pDecoderStream,
6923  CElement * pElement);
6925 
6926 
6927  protected:
6928  llrp_s16_t m_RSSI;
6929 
6932  public:
6933  static const CFieldDescriptor
6934  s_fdRSSI;
6936 
6938  inline llrp_s16_t
6939  getRSSI (void)
6940  {
6941  return m_RSSI;
6942  }
6943 
6945  inline void
6947  llrp_s16_t value)
6948  {
6949  m_RSSI = value;
6950  }
6951 
6952 
6953 
6954  protected:
6955  std::list<CParameter *> m_listCustom;
6956 
6957  public:
6959  inline std::list<CParameter *>::iterator
6961  {
6962  return m_listCustom.begin();
6963  }
6964 
6966  inline std::list<CParameter *>::iterator
6967  endCustom (void)
6968  {
6969  return m_listCustom.end();
6970  }
6971 
6973  inline void
6975  {
6976  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6977  }
6978 
6980  inline int
6982  {
6983  return (int) (m_listCustom.size());
6984  }
6985 
6986  EResultCode
6988  addCustom (
6989  CParameter * pValue);
6990 
6991 
6992 };
6993 
6994 
7020 class CImpinjGPSCoordinates : public CParameter
7021 {
7022  public:
7023  CImpinjGPSCoordinates (void);
7024  ~CImpinjGPSCoordinates (void);
7025 
7028 
7029  static const CFieldDescriptor * const
7030  s_apFieldDescriptorTable[];
7031 
7032  static const CTypeDescriptor
7033  s_typeDescriptor;
7034 
7035  void
7036  decodeFields (
7037  CDecoderStream * pDecoderStream);
7038 
7039  void
7040  assimilateSubParameters (
7041  CErrorDetails * pError);
7042 
7043  void
7044  encode (
7045  CEncoderStream * pEncoderStream) const;
7046 
7047 
7048  llrp_bool_t
7049  isAllowedIn (
7050  const CTypeDescriptor * pEnclosingElementType) const;
7051 
7052 
7053  static CElement *
7054  s_construct (void);
7055 
7056  static void
7057  s_decodeFields (
7058  CDecoderStream * pDecoderStream,
7059  CElement * pElement);
7061 
7062 
7063  protected:
7064  llrp_s32_t m_Latitude;
7065 
7068  public:
7069  static const CFieldDescriptor
7070  s_fdLatitude;
7072 
7074  inline llrp_s32_t
7076  {
7077  return m_Latitude;
7078  }
7079 
7081  inline void
7083  llrp_s32_t value)
7084  {
7085  m_Latitude = value;
7086  }
7087 
7088 
7089  protected:
7090  llrp_s32_t m_Longitude;
7091 
7094  public:
7095  static const CFieldDescriptor
7096  s_fdLongitude;
7098 
7100  inline llrp_s32_t
7102  {
7103  return m_Longitude;
7104  }
7105 
7107  inline void
7109  llrp_s32_t value)
7110  {
7111  m_Longitude = value;
7112  }
7113 
7114 
7115 
7116  protected:
7117  std::list<CParameter *> m_listCustom;
7118 
7119  public:
7121  inline std::list<CParameter *>::iterator
7123  {
7124  return m_listCustom.begin();
7125  }
7126 
7128  inline std::list<CParameter *>::iterator
7129  endCustom (void)
7130  {
7131  return m_listCustom.end();
7132  }
7133 
7135  inline void
7137  {
7138  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7139  }
7140 
7142  inline int
7144  {
7145  return (int) (m_listCustom.size());
7146  }
7147 
7148  EResultCode
7150  addCustom (
7151  CParameter * pValue);
7152 
7153 
7154 };
7155 
7156 
7181 class CImpinjLoopSpec : public CParameter
7182 {
7183  public:
7184  CImpinjLoopSpec (void);
7185  ~CImpinjLoopSpec (void);
7186 
7189 
7190  static const CFieldDescriptor * const
7191  s_apFieldDescriptorTable[];
7192 
7193  static const CTypeDescriptor
7194  s_typeDescriptor;
7195 
7196  void
7197  decodeFields (
7198  CDecoderStream * pDecoderStream);
7199 
7200  void
7201  assimilateSubParameters (
7202  CErrorDetails * pError);
7203 
7204  void
7205  encode (
7206  CEncoderStream * pEncoderStream) const;
7207 
7208 
7209  llrp_bool_t
7210  isAllowedIn (
7211  const CTypeDescriptor * pEnclosingElementType) const;
7212 
7213 
7214  static CElement *
7215  s_construct (void);
7216 
7217  static void
7218  s_decodeFields (
7219  CDecoderStream * pDecoderStream,
7220  CElement * pElement);
7222 
7223 
7224  protected:
7225  llrp_u32_t m_LoopCount;
7226 
7229  public:
7230  static const CFieldDescriptor
7231  s_fdLoopCount;
7233 
7235  inline llrp_u32_t
7237  {
7238  return m_LoopCount;
7239  }
7240 
7242  inline void
7244  llrp_u32_t value)
7245  {
7246  m_LoopCount = value;
7247  }
7248 
7249 
7250 
7251  protected:
7252  std::list<CParameter *> m_listCustom;
7253 
7254  public:
7256  inline std::list<CParameter *>::iterator
7258  {
7259  return m_listCustom.begin();
7260  }
7261 
7263  inline std::list<CParameter *>::iterator
7264  endCustom (void)
7265  {
7266  return m_listCustom.end();
7267  }
7268 
7270  inline void
7272  {
7273  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7274  }
7275 
7277  inline int
7279  {
7280  return (int) (m_listCustom.size());
7281  }
7282 
7283  EResultCode
7285  addCustom (
7286  CParameter * pValue);
7287 
7288 
7289 };
7290 
7291 
7317 class CImpinjGPSNMEASentences : public CParameter
7318 {
7319  public:
7320  CImpinjGPSNMEASentences (void);
7321  ~CImpinjGPSNMEASentences (void);
7322 
7325 
7326  static const CFieldDescriptor * const
7327  s_apFieldDescriptorTable[];
7328 
7329  static const CTypeDescriptor
7330  s_typeDescriptor;
7331 
7332  void
7333  decodeFields (
7334  CDecoderStream * pDecoderStream);
7335 
7336  void
7337  assimilateSubParameters (
7338  CErrorDetails * pError);
7339 
7340  void
7341  encode (
7342  CEncoderStream * pEncoderStream) const;
7343 
7344 
7345  llrp_bool_t
7346  isAllowedIn (
7347  const CTypeDescriptor * pEnclosingElementType) const;
7348 
7349 
7350  static CElement *
7351  s_construct (void);
7352 
7353  static void
7354  s_decodeFields (
7355  CDecoderStream * pDecoderStream,
7356  CElement * pElement);
7358 
7359 
7360 
7361  protected:
7362  CImpinjGGASentence * m_pImpinjGGASentence;
7363 
7364  public:
7366  inline CImpinjGGASentence *
7368  {
7369  return m_pImpinjGGASentence;
7370  }
7371 
7373  EResultCode
7374  setImpinjGGASentence (
7375  CImpinjGGASentence * pValue);
7376 
7377 
7378  protected:
7379  CImpinjRMCSentence * m_pImpinjRMCSentence;
7380 
7381  public:
7383  inline CImpinjRMCSentence *
7385  {
7386  return m_pImpinjRMCSentence;
7387  }
7388 
7390  EResultCode
7391  setImpinjRMCSentence (
7392  CImpinjRMCSentence * pValue);
7393 
7394 
7395  protected:
7396  std::list<CParameter *> m_listCustom;
7397 
7398  public:
7400  inline std::list<CParameter *>::iterator
7402  {
7403  return m_listCustom.begin();
7404  }
7405 
7407  inline std::list<CParameter *>::iterator
7408  endCustom (void)
7409  {
7410  return m_listCustom.end();
7411  }
7412 
7414  inline void
7416  {
7417  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7418  }
7419 
7421  inline int
7423  {
7424  return (int) (m_listCustom.size());
7425  }
7426 
7427  EResultCode
7429  addCustom (
7430  CParameter * pValue);
7431 
7432 
7433 };
7434 
7435 
7459 class CImpinjGGASentence : public CParameter
7460 {
7461  public:
7462  CImpinjGGASentence (void);
7463  ~CImpinjGGASentence (void);
7464 
7467 
7468  static const CFieldDescriptor * const
7469  s_apFieldDescriptorTable[];
7470 
7471  static const CTypeDescriptor
7472  s_typeDescriptor;
7473 
7474  void
7475  decodeFields (
7476  CDecoderStream * pDecoderStream);
7477 
7478  void
7479  assimilateSubParameters (
7480  CErrorDetails * pError);
7481 
7482  void
7483  encode (
7484  CEncoderStream * pEncoderStream) const;
7485 
7486 
7487  llrp_bool_t
7488  isAllowedIn (
7489  const CTypeDescriptor * pEnclosingElementType) const;
7490 
7491 
7492  static CElement *
7493  s_construct (void);
7494 
7495  static void
7496  s_decodeFields (
7497  CDecoderStream * pDecoderStream,
7498  CElement * pElement);
7500 
7501 
7502  protected:
7503  llrp_utf8v_t m_GGASentence;
7504 
7507  public:
7508  static const CFieldDescriptor
7509  s_fdGGASentence;
7511 
7513  inline llrp_utf8v_t
7515  {
7516  return m_GGASentence;
7517  }
7518 
7520  inline void
7522  llrp_utf8v_t value)
7523  {
7524  m_GGASentence = value;
7525  }
7526 
7527 
7528 
7529  protected:
7530  std::list<CParameter *> m_listCustom;
7531 
7532  public:
7534  inline std::list<CParameter *>::iterator
7536  {
7537  return m_listCustom.begin();
7538  }
7539 
7541  inline std::list<CParameter *>::iterator
7542  endCustom (void)
7543  {
7544  return m_listCustom.end();
7545  }
7546 
7548  inline void
7550  {
7551  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7552  }
7553 
7555  inline int
7557  {
7558  return (int) (m_listCustom.size());
7559  }
7560 
7561  EResultCode
7563  addCustom (
7564  CParameter * pValue);
7565 
7566 
7567 };
7568 
7569 
7593 class CImpinjRMCSentence : public CParameter
7594 {
7595  public:
7596  CImpinjRMCSentence (void);
7597  ~CImpinjRMCSentence (void);
7598 
7601 
7602  static const CFieldDescriptor * const
7603  s_apFieldDescriptorTable[];
7604 
7605  static const CTypeDescriptor
7606  s_typeDescriptor;
7607 
7608  void
7609  decodeFields (
7610  CDecoderStream * pDecoderStream);
7611 
7612  void
7613  assimilateSubParameters (
7614  CErrorDetails * pError);
7615 
7616  void
7617  encode (
7618  CEncoderStream * pEncoderStream) const;
7619 
7620 
7621  llrp_bool_t
7622  isAllowedIn (
7623  const CTypeDescriptor * pEnclosingElementType) const;
7624 
7625 
7626  static CElement *
7627  s_construct (void);
7628 
7629  static void
7630  s_decodeFields (
7631  CDecoderStream * pDecoderStream,
7632  CElement * pElement);
7634 
7635 
7636  protected:
7637  llrp_utf8v_t m_RMCSentence;
7638 
7641  public:
7642  static const CFieldDescriptor
7643  s_fdRMCSentence;
7645 
7647  inline llrp_utf8v_t
7649  {
7650  return m_RMCSentence;
7651  }
7652 
7654  inline void
7656  llrp_utf8v_t value)
7657  {
7658  m_RMCSentence = value;
7659  }
7660 
7661 
7662 
7663  protected:
7664  std::list<CParameter *> m_listCustom;
7665 
7666  public:
7668  inline std::list<CParameter *>::iterator
7670  {
7671  return m_listCustom.begin();
7672  }
7673 
7675  inline std::list<CParameter *>::iterator
7676  endCustom (void)
7677  {
7678  return m_listCustom.end();
7679  }
7680 
7682  inline void
7684  {
7685  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7686  }
7687 
7689  inline int
7691  {
7692  return (int) (m_listCustom.size());
7693  }
7694 
7695  EResultCode
7697  addCustom (
7698  CParameter * pValue);
7699 
7700 
7701 };
7702 
7703 
7727 class CImpinjOpSpecRetryCount : public CParameter
7728 {
7729  public:
7730  CImpinjOpSpecRetryCount (void);
7731  ~CImpinjOpSpecRetryCount (void);
7732 
7735 
7736  static const CFieldDescriptor * const
7737  s_apFieldDescriptorTable[];
7738 
7739  static const CTypeDescriptor
7740  s_typeDescriptor;
7741 
7742  void
7743  decodeFields (
7744  CDecoderStream * pDecoderStream);
7745 
7746  void
7747  assimilateSubParameters (
7748  CErrorDetails * pError);
7749 
7750  void
7751  encode (
7752  CEncoderStream * pEncoderStream) const;
7753 
7754 
7755  llrp_bool_t
7756  isAllowedIn (
7757  const CTypeDescriptor * pEnclosingElementType) const;
7758 
7759 
7760  static CElement *
7761  s_construct (void);
7762 
7763  static void
7764  s_decodeFields (
7765  CDecoderStream * pDecoderStream,
7766  CElement * pElement);
7768 
7769 
7770  protected:
7771  llrp_u16_t m_RetryCount;
7772 
7775  public:
7776  static const CFieldDescriptor
7777  s_fdRetryCount;
7779 
7781  inline llrp_u16_t
7783  {
7784  return m_RetryCount;
7785  }
7786 
7788  inline void
7790  llrp_u16_t value)
7791  {
7792  m_RetryCount = value;
7793  }
7794 
7795 
7796 
7797  protected:
7798  std::list<CParameter *> m_listCustom;
7799 
7800  public:
7802  inline std::list<CParameter *>::iterator
7804  {
7805  return m_listCustom.begin();
7806  }
7807 
7809  inline std::list<CParameter *>::iterator
7810  endCustom (void)
7811  {
7812  return m_listCustom.end();
7813  }
7814 
7816  inline void
7818  {
7819  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7820  }
7821 
7823  inline int
7825  {
7826  return (int) (m_listCustom.size());
7827  }
7828 
7829  EResultCode
7831  addCustom (
7832  CParameter * pValue);
7833 
7834 
7835 };
7836 
7837 
7865 class CImpinjAdvancedGPOConfiguration : public CParameter
7866 {
7867  public:
7870 
7873 
7874  static const CFieldDescriptor * const
7875  s_apFieldDescriptorTable[];
7876 
7877  static const CTypeDescriptor
7878  s_typeDescriptor;
7879 
7880  void
7881  decodeFields (
7882  CDecoderStream * pDecoderStream);
7883 
7884  void
7885  assimilateSubParameters (
7886  CErrorDetails * pError);
7887 
7888  void
7889  encode (
7890  CEncoderStream * pEncoderStream) const;
7891 
7892 
7893  llrp_bool_t
7894  isAllowedIn (
7895  const CTypeDescriptor * pEnclosingElementType) const;
7896 
7897 
7898  static CElement *
7899  s_construct (void);
7900 
7901  static void
7902  s_decodeFields (
7903  CDecoderStream * pDecoderStream,
7904  CElement * pElement);
7906 
7907 
7908  protected:
7909  llrp_u16_t m_GPOPortNum;
7910 
7913  public:
7914  static const CFieldDescriptor
7915  s_fdGPOPortNum;
7917 
7919  inline llrp_u16_t
7921  {
7922  return m_GPOPortNum;
7923  }
7924 
7926  inline void
7928  llrp_u16_t value)
7929  {
7930  m_GPOPortNum = value;
7931  }
7932 
7933 
7934  protected:
7935  EImpinjAdvancedGPOMode m_eGPOMode;
7936 
7939  public:
7940  static const CFieldDescriptor
7941  s_fdGPOMode;
7943 
7945  inline EImpinjAdvancedGPOMode
7946  getGPOMode (void)
7947  {
7948  return m_eGPOMode;
7949  }
7950 
7952  inline void
7954  EImpinjAdvancedGPOMode value)
7955  {
7956  m_eGPOMode = value;
7957  }
7958 
7959 
7960  protected:
7961  llrp_u32_t m_GPOPulseDurationMSec;
7962 
7965  public:
7966  static const CFieldDescriptor
7967  s_fdGPOPulseDurationMSec;
7969 
7971  inline llrp_u32_t
7973  {
7974  return m_GPOPulseDurationMSec;
7975  }
7976 
7978  inline void
7980  llrp_u32_t value)
7981  {
7982  m_GPOPulseDurationMSec = value;
7983  }
7984 
7985 
7986 
7987  protected:
7988  std::list<CParameter *> m_listCustom;
7989 
7990  public:
7992  inline std::list<CParameter *>::iterator
7994  {
7995  return m_listCustom.begin();
7996  }
7997 
7999  inline std::list<CParameter *>::iterator
8000  endCustom (void)
8001  {
8002  return m_listCustom.end();
8003  }
8004 
8006  inline void
8008  {
8009  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8010  }
8011 
8013  inline int
8015  {
8016  return (int) (m_listCustom.size());
8017  }
8018 
8019  EResultCode
8021  addCustom (
8022  CParameter * pValue);
8023 
8024 
8025 };
8026 
8027 
8061 class CImpinjEnableOptimizedRead : public CParameter
8062 {
8063  public:
8066 
8069 
8070  static const CFieldDescriptor * const
8071  s_apFieldDescriptorTable[];
8072 
8073  static const CTypeDescriptor
8074  s_typeDescriptor;
8075 
8076  void
8077  decodeFields (
8078  CDecoderStream * pDecoderStream);
8079 
8080  void
8081  assimilateSubParameters (
8082  CErrorDetails * pError);
8083 
8084  void
8085  encode (
8086  CEncoderStream * pEncoderStream) const;
8087 
8088 
8089  llrp_bool_t
8090  isAllowedIn (
8091  const CTypeDescriptor * pEnclosingElementType) const;
8092 
8093 
8094  static CElement *
8095  s_construct (void);
8096 
8097  static void
8098  s_decodeFields (
8099  CDecoderStream * pDecoderStream,
8100  CElement * pElement);
8102 
8103 
8104  protected:
8105  EImpinjOptimizedReadMode m_eOptimizedReadMode;
8106 
8109  public:
8110  static const CFieldDescriptor
8111  s_fdOptimizedReadMode;
8113 
8115  inline EImpinjOptimizedReadMode
8117  {
8118  return m_eOptimizedReadMode;
8119  }
8120 
8122  inline void
8124  EImpinjOptimizedReadMode value)
8125  {
8126  m_eOptimizedReadMode = value;
8127  }
8128 
8129 
8130 
8131  protected:
8132  std::list<CC1G2Read *> m_listC1G2Read;
8133 
8134  public:
8136  inline std::list<CC1G2Read *>::iterator
8138  {
8139  return m_listC1G2Read.begin();
8140  }
8141 
8143  inline std::list<CC1G2Read *>::iterator
8145  {
8146  return m_listC1G2Read.end();
8147  }
8148 
8150  inline void
8152  {
8153  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
8154  }
8155 
8157  inline int
8159  {
8160  return (int) (m_listC1G2Read.size());
8161  }
8162 
8163  EResultCode
8165  addC1G2Read (
8166  CC1G2Read * pValue);
8167 
8168 
8169  protected:
8170  std::list<CParameter *> m_listCustom;
8171 
8172  public:
8174  inline std::list<CParameter *>::iterator
8176  {
8177  return m_listCustom.begin();
8178  }
8179 
8181  inline std::list<CParameter *>::iterator
8182  endCustom (void)
8183  {
8184  return m_listCustom.end();
8185  }
8186 
8188  inline void
8190  {
8191  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8192  }
8193 
8195  inline int
8197  {
8198  return (int) (m_listCustom.size());
8199  }
8200 
8201  EResultCode
8203  addCustom (
8204  CParameter * pValue);
8205 
8206 
8207 };
8208 
8209 
8236 class CImpinjAccessSpecOrdering : public CParameter
8237 {
8238  public:
8240  ~CImpinjAccessSpecOrdering (void);
8241 
8244 
8245  static const CFieldDescriptor * const
8246  s_apFieldDescriptorTable[];
8247 
8248  static const CTypeDescriptor
8249  s_typeDescriptor;
8250 
8251  void
8252  decodeFields (
8253  CDecoderStream * pDecoderStream);
8254 
8255  void
8256  assimilateSubParameters (
8257  CErrorDetails * pError);
8258 
8259  void
8260  encode (
8261  CEncoderStream * pEncoderStream) const;
8262 
8263 
8264  llrp_bool_t
8265  isAllowedIn (
8266  const CTypeDescriptor * pEnclosingElementType) const;
8267 
8268 
8269  static CElement *
8270  s_construct (void);
8271 
8272  static void
8273  s_decodeFields (
8274  CDecoderStream * pDecoderStream,
8275  CElement * pElement);
8277 
8278 
8279  protected:
8280  EImpinjAccessSpecOrderingMode m_eOrderingMode;
8281 
8284  public:
8285  static const CFieldDescriptor
8286  s_fdOrderingMode;
8288 
8290  inline EImpinjAccessSpecOrderingMode
8292  {
8293  return m_eOrderingMode;
8294  }
8295 
8297  inline void
8299  EImpinjAccessSpecOrderingMode value)
8300  {
8301  m_eOrderingMode = value;
8302  }
8303 
8304 
8305 
8306  protected:
8307  std::list<CParameter *> m_listCustom;
8308 
8309  public:
8311  inline std::list<CParameter *>::iterator
8313  {
8314  return m_listCustom.begin();
8315  }
8316 
8318  inline std::list<CParameter *>::iterator
8319  endCustom (void)
8320  {
8321  return m_listCustom.end();
8322  }
8323 
8325  inline void
8327  {
8328  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8329  }
8330 
8332  inline int
8334  {
8335  return (int) (m_listCustom.size());
8336  }
8337 
8338  EResultCode
8340  addCustom (
8341  CParameter * pValue);
8342 
8343 
8344 };
8345 
8346 
8370 class CImpinjEnableRFDopplerFrequency : public CParameter
8371 {
8372  public:
8375 
8378 
8379  static const CFieldDescriptor * const
8380  s_apFieldDescriptorTable[];
8381 
8382  static const CTypeDescriptor
8383  s_typeDescriptor;
8384 
8385  void
8386  decodeFields (
8387  CDecoderStream * pDecoderStream);
8388 
8389  void
8390  assimilateSubParameters (
8391  CErrorDetails * pError);
8392 
8393  void
8394  encode (
8395  CEncoderStream * pEncoderStream) const;
8396 
8397 
8398  llrp_bool_t
8399  isAllowedIn (
8400  const CTypeDescriptor * pEnclosingElementType) const;
8401 
8402 
8403  static CElement *
8404  s_construct (void);
8405 
8406  static void
8407  s_decodeFields (
8408  CDecoderStream * pDecoderStream,
8409  CElement * pElement);
8411 
8412 
8413  protected:
8414  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8415 
8418  public:
8419  static const CFieldDescriptor
8420  s_fdRFDopplerFrequencyMode;
8422 
8424  inline EImpinjRFDopplerFrequencyMode
8426  {
8427  return m_eRFDopplerFrequencyMode;
8428  }
8429 
8431  inline void
8433  EImpinjRFDopplerFrequencyMode value)
8434  {
8435  m_eRFDopplerFrequencyMode = value;
8436  }
8437 
8438 
8439 
8440  protected:
8441  std::list<CParameter *> m_listCustom;
8442 
8443  public:
8445  inline std::list<CParameter *>::iterator
8447  {
8448  return m_listCustom.begin();
8449  }
8450 
8452  inline std::list<CParameter *>::iterator
8453  endCustom (void)
8454  {
8455  return m_listCustom.end();
8456  }
8457 
8459  inline void
8461  {
8462  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8463  }
8464 
8466  inline int
8468  {
8469  return (int) (m_listCustom.size());
8470  }
8471 
8472  EResultCode
8474  addCustom (
8475  CParameter * pValue);
8476 
8477 
8478 };
8479 
8480 
8505 class CImpinjRFDopplerFrequency : public CParameter
8506 {
8507  public:
8509  ~CImpinjRFDopplerFrequency (void);
8510 
8513 
8514  static const CFieldDescriptor * const
8515  s_apFieldDescriptorTable[];
8516 
8517  static const CTypeDescriptor
8518  s_typeDescriptor;
8519 
8520  void
8521  decodeFields (
8522  CDecoderStream * pDecoderStream);
8523 
8524  void
8525  assimilateSubParameters (
8526  CErrorDetails * pError);
8527 
8528  void
8529  encode (
8530  CEncoderStream * pEncoderStream) const;
8531 
8532 
8533  llrp_bool_t
8534  isAllowedIn (
8535  const CTypeDescriptor * pEnclosingElementType) const;
8536 
8537 
8538  static CElement *
8539  s_construct (void);
8540 
8541  static void
8542  s_decodeFields (
8543  CDecoderStream * pDecoderStream,
8544  CElement * pElement);
8546 
8547 
8548  protected:
8549  llrp_s16_t m_DopplerFrequency;
8550 
8553  public:
8554  static const CFieldDescriptor
8555  s_fdDopplerFrequency;
8557 
8559  inline llrp_s16_t
8561  {
8562  return m_DopplerFrequency;
8563  }
8564 
8566  inline void
8568  llrp_s16_t value)
8569  {
8570  m_DopplerFrequency = value;
8571  }
8572 
8573 
8574 
8575  protected:
8576  std::list<CParameter *> m_listCustom;
8577 
8578  public:
8580  inline std::list<CParameter *>::iterator
8582  {
8583  return m_listCustom.begin();
8584  }
8585 
8587  inline std::list<CParameter *>::iterator
8588  endCustom (void)
8589  {
8590  return m_listCustom.end();
8591  }
8592 
8594  inline void
8596  {
8597  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8598  }
8599 
8601  inline int
8603  {
8604  return (int) (m_listCustom.size());
8605  }
8606 
8607  EResultCode
8609  addCustom (
8610  CParameter * pValue);
8611 
8612 
8613 };
8614 
8615 
8648 class CImpinjInventoryConfiguration : public CParameter
8649 {
8650  public:
8653 
8656 
8657  static const CFieldDescriptor * const
8658  s_apFieldDescriptorTable[];
8659 
8660  static const CTypeDescriptor
8661  s_typeDescriptor;
8662 
8663  void
8664  decodeFields (
8665  CDecoderStream * pDecoderStream);
8666 
8667  void
8668  assimilateSubParameters (
8669  CErrorDetails * pError);
8670 
8671  void
8672  encode (
8673  CEncoderStream * pEncoderStream) const;
8674 
8675 
8676  llrp_bool_t
8677  isAllowedIn (
8678  const CTypeDescriptor * pEnclosingElementType) const;
8679 
8680 
8681  static CElement *
8682  s_construct (void);
8683 
8684  static void
8685  s_decodeFields (
8686  CDecoderStream * pDecoderStream,
8687  CElement * pElement);
8689 
8690 
8691  protected:
8692  llrp_u1_t m_EnableAntDwellTimeLimit;
8693 
8696  public:
8697  static const CFieldDescriptor
8698  s_fdEnableAntDwellTimeLimit;
8700 
8702  inline llrp_u1_t
8704  {
8705  return m_EnableAntDwellTimeLimit;
8706  }
8707 
8709  inline void
8711  llrp_u1_t value)
8712  {
8713  m_EnableAntDwellTimeLimit = value;
8714  }
8715 
8716 
8717  protected:
8718  llrp_u1_t m_EnableSelectGapClose;
8719 
8722  public:
8723  static const CFieldDescriptor
8724  s_fdEnableSelectGapClose;
8726 
8728  inline llrp_u1_t
8730  {
8731  return m_EnableSelectGapClose;
8732  }
8733 
8735  inline void
8737  llrp_u1_t value)
8738  {
8739  m_EnableSelectGapClose = value;
8740  }
8741 
8742 
8743 
8744  protected:
8745  std::list<CParameter *> m_listCustom;
8746 
8747  public:
8749  inline std::list<CParameter *>::iterator
8751  {
8752  return m_listCustom.begin();
8753  }
8754 
8756  inline std::list<CParameter *>::iterator
8757  endCustom (void)
8758  {
8759  return m_listCustom.end();
8760  }
8761 
8763  inline void
8765  {
8766  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8767  }
8768 
8770  inline int
8772  {
8773  return (int) (m_listCustom.size());
8774  }
8775 
8776  EResultCode
8778  addCustom (
8779  CParameter * pValue);
8780 
8781 
8782 };
8783 
8784 
8808 class CImpinjEnableTxPower : public CParameter
8809 {
8810  public:
8811  CImpinjEnableTxPower (void);
8812  ~CImpinjEnableTxPower (void);
8813 
8816 
8817  static const CFieldDescriptor * const
8818  s_apFieldDescriptorTable[];
8819 
8820  static const CTypeDescriptor
8821  s_typeDescriptor;
8822 
8823  void
8824  decodeFields (
8825  CDecoderStream * pDecoderStream);
8826 
8827  void
8828  assimilateSubParameters (
8829  CErrorDetails * pError);
8830 
8831  void
8832  encode (
8833  CEncoderStream * pEncoderStream) const;
8834 
8835 
8836  llrp_bool_t
8837  isAllowedIn (
8838  const CTypeDescriptor * pEnclosingElementType) const;
8839 
8840 
8841  static CElement *
8842  s_construct (void);
8843 
8844  static void
8845  s_decodeFields (
8846  CDecoderStream * pDecoderStream,
8847  CElement * pElement);
8849 
8850 
8851  protected:
8852  EImpinjTxPowerReportingModeEnum m_eTxPowerReportingMode;
8853 
8856  public:
8857  static const CFieldDescriptor
8858  s_fdTxPowerReportingMode;
8860 
8862  inline EImpinjTxPowerReportingModeEnum
8864  {
8865  return m_eTxPowerReportingMode;
8866  }
8867 
8869  inline void
8871  EImpinjTxPowerReportingModeEnum value)
8872  {
8873  m_eTxPowerReportingMode = value;
8874  }
8875 
8876 
8877 
8878  protected:
8879  std::list<CParameter *> m_listCustom;
8880 
8881  public:
8883  inline std::list<CParameter *>::iterator
8885  {
8886  return m_listCustom.begin();
8887  }
8888 
8890  inline std::list<CParameter *>::iterator
8891  endCustom (void)
8892  {
8893  return m_listCustom.end();
8894  }
8895 
8897  inline void
8899  {
8900  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8901  }
8902 
8904  inline int
8906  {
8907  return (int) (m_listCustom.size());
8908  }
8909 
8910  EResultCode
8912  addCustom (
8913  CParameter * pValue);
8914 
8915 
8916 };
8917 
8918 
8943 class CImpinjTxPower : public CParameter
8944 {
8945  public:
8946  CImpinjTxPower (void);
8947  ~CImpinjTxPower (void);
8948 
8951 
8952  static const CFieldDescriptor * const
8953  s_apFieldDescriptorTable[];
8954 
8955  static const CTypeDescriptor
8956  s_typeDescriptor;
8957 
8958  void
8959  decodeFields (
8960  CDecoderStream * pDecoderStream);
8961 
8962  void
8963  assimilateSubParameters (
8964  CErrorDetails * pError);
8965 
8966  void
8967  encode (
8968  CEncoderStream * pEncoderStream) const;
8969 
8970 
8971  llrp_bool_t
8972  isAllowedIn (
8973  const CTypeDescriptor * pEnclosingElementType) const;
8974 
8975 
8976  static CElement *
8977  s_construct (void);
8978 
8979  static void
8980  s_decodeFields (
8981  CDecoderStream * pDecoderStream,
8982  CElement * pElement);
8984 
8985 
8986  protected:
8987  llrp_u16_t m_TxPower;
8988 
8991  public:
8992  static const CFieldDescriptor
8993  s_fdTxPower;
8995 
8997  inline llrp_u16_t
8998  getTxPower (void)
8999  {
9000  return m_TxPower;
9001  }
9002 
9004  inline void
9006  llrp_u16_t value)
9007  {
9008  m_TxPower = value;
9009  }
9010 
9011 
9012 
9013  protected:
9014  std::list<CParameter *> m_listCustom;
9015 
9016  public:
9018  inline std::list<CParameter *>::iterator
9020  {
9021  return m_listCustom.begin();
9022  }
9023 
9025  inline std::list<CParameter *>::iterator
9026  endCustom (void)
9027  {
9028  return m_listCustom.end();
9029  }
9030 
9032  inline void
9034  {
9035  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9036  }
9037 
9039  inline int
9041  {
9042  return (int) (m_listCustom.size());
9043  }
9044 
9045  EResultCode
9047  addCustom (
9048  CParameter * pValue);
9049 
9050 
9051 };
9052 
9053 
9080 class CImpinjArrayVersion : public CParameter
9081 {
9082  public:
9083  CImpinjArrayVersion (void);
9084  ~CImpinjArrayVersion (void);
9085 
9088 
9089  static const CFieldDescriptor * const
9090  s_apFieldDescriptorTable[];
9091 
9092  static const CTypeDescriptor
9093  s_typeDescriptor;
9094 
9095  void
9096  decodeFields (
9097  CDecoderStream * pDecoderStream);
9098 
9099  void
9100  assimilateSubParameters (
9101  CErrorDetails * pError);
9102 
9103  void
9104  encode (
9105  CEncoderStream * pEncoderStream) const;
9106 
9107 
9108  llrp_bool_t
9109  isAllowedIn (
9110  const CTypeDescriptor * pEnclosingElementType) const;
9111 
9112 
9113  static CElement *
9114  s_construct (void);
9115 
9116  static void
9117  s_decodeFields (
9118  CDecoderStream * pDecoderStream,
9119  CElement * pElement);
9121 
9122 
9123  protected:
9124  llrp_utf8v_t m_SerialNumber;
9125 
9128  public:
9129  static const CFieldDescriptor
9130  s_fdSerialNumber;
9132 
9134  inline llrp_utf8v_t
9136  {
9137  return m_SerialNumber;
9138  }
9139 
9141  inline void
9143  llrp_utf8v_t value)
9144  {
9145  m_SerialNumber = value;
9146  }
9147 
9148 
9149  protected:
9150  llrp_utf8v_t m_FirmwareVersion;
9151 
9154  public:
9155  static const CFieldDescriptor
9156  s_fdFirmwareVersion;
9158 
9160  inline llrp_utf8v_t
9162  {
9163  return m_FirmwareVersion;
9164  }
9165 
9167  inline void
9169  llrp_utf8v_t value)
9170  {
9171  m_FirmwareVersion = value;
9172  }
9173 
9174 
9175  protected:
9176  llrp_utf8v_t m_PCBAVersion;
9177 
9180  public:
9181  static const CFieldDescriptor
9182  s_fdPCBAVersion;
9184 
9186  inline llrp_utf8v_t
9188  {
9189  return m_PCBAVersion;
9190  }
9191 
9193  inline void
9195  llrp_utf8v_t value)
9196  {
9197  m_PCBAVersion = value;
9198  }
9199 
9200 
9201 
9202  protected:
9203  std::list<CParameter *> m_listCustom;
9204 
9205  public:
9207  inline std::list<CParameter *>::iterator
9209  {
9210  return m_listCustom.begin();
9211  }
9212 
9214  inline std::list<CParameter *>::iterator
9215  endCustom (void)
9216  {
9217  return m_listCustom.end();
9218  }
9219 
9221  inline void
9223  {
9224  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9225  }
9226 
9228  inline int
9230  {
9231  return (int) (m_listCustom.size());
9232  }
9233 
9234  EResultCode
9236  addCustom (
9237  CParameter * pValue);
9238 
9239 
9240 };
9241 
9242 
9275 class CImpinjxArrayCapabilities : public CParameter
9276 {
9277  public:
9279  ~CImpinjxArrayCapabilities (void);
9280 
9283 
9284  static const CFieldDescriptor * const
9285  s_apFieldDescriptorTable[];
9286 
9287  static const CTypeDescriptor
9288  s_typeDescriptor;
9289 
9290  void
9291  decodeFields (
9292  CDecoderStream * pDecoderStream);
9293 
9294  void
9295  assimilateSubParameters (
9296  CErrorDetails * pError);
9297 
9298  void
9299  encode (
9300  CEncoderStream * pEncoderStream) const;
9301 
9302 
9303  llrp_bool_t
9304  isAllowedIn (
9305  const CTypeDescriptor * pEnclosingElementType) const;
9306 
9307 
9308  static CElement *
9309  s_construct (void);
9310 
9311  static void
9312  s_decodeFields (
9313  CDecoderStream * pDecoderStream,
9314  CElement * pElement);
9316 
9317 
9318  protected:
9319  llrp_u32_t m_MaxNumSectors;
9320 
9323  public:
9324  static const CFieldDescriptor
9325  s_fdMaxNumSectors;
9327 
9329  inline llrp_u32_t
9331  {
9332  return m_MaxNumSectors;
9333  }
9334 
9336  inline void
9338  llrp_u32_t value)
9339  {
9340  m_MaxNumSectors = value;
9341  }
9342 
9343 
9344  protected:
9345  llrp_u1_t m_SupportsLISpecs;
9346 
9349  public:
9350  static const CFieldDescriptor
9351  s_fdSupportsLISpecs;
9353 
9355  inline llrp_u1_t
9357  {
9358  return m_SupportsLISpecs;
9359  }
9360 
9362  inline void
9364  llrp_u1_t value)
9365  {
9366  m_SupportsLISpecs = value;
9367  }
9368 
9369 
9370  protected:
9371  llrp_u1_t m_SupportsTISpecs;
9372 
9375  public:
9376  static const CFieldDescriptor
9377  s_fdSupportsTISpecs;
9379 
9381  inline llrp_u1_t
9383  {
9384  return m_SupportsTISpecs;
9385  }
9386 
9388  inline void
9390  llrp_u1_t value)
9391  {
9392  m_SupportsTISpecs = value;
9393  }
9394 
9395 
9396  protected:
9397  llrp_u1_t m_SupportsTSISpecs;
9398 
9401  public:
9402  static const CFieldDescriptor
9403  s_fdSupportsTSISpecs;
9405 
9407  inline llrp_u1_t
9409  {
9410  return m_SupportsTSISpecs;
9411  }
9412 
9414  inline void
9416  llrp_u1_t value)
9417  {
9418  m_SupportsTSISpecs = value;
9419  }
9420 
9421 
9422  protected:
9423  llrp_u1_t m_SupportsDISpecs;
9424 
9427  public:
9428  static const CFieldDescriptor
9429  s_fdSupportsDISpecs;
9431 
9433  inline llrp_u1_t
9435  {
9436  return m_SupportsDISpecs;
9437  }
9438 
9440  inline void
9442  llrp_u1_t value)
9443  {
9444  m_SupportsDISpecs = value;
9445  }
9446 
9447 
9448 
9449  protected:
9450  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
9451 
9452  public:
9456  {
9457  return m_pImpinjxArrayDirectionCapabilities;
9458  }
9459 
9461  EResultCode
9462  setImpinjxArrayDirectionCapabilities (
9464 
9465 
9466  protected:
9467  std::list<CParameter *> m_listCustom;
9468 
9469  public:
9471  inline std::list<CParameter *>::iterator
9473  {
9474  return m_listCustom.begin();
9475  }
9476 
9478  inline std::list<CParameter *>::iterator
9479  endCustom (void)
9480  {
9481  return m_listCustom.end();
9482  }
9483 
9485  inline void
9487  {
9488  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9489  }
9490 
9492  inline int
9494  {
9495  return (int) (m_listCustom.size());
9496  }
9497 
9498  EResultCode
9500  addCustom (
9501  CParameter * pValue);
9502 
9503 
9504 };
9505 
9506 
9534 class CImpinjTiltConfiguration : public CParameter
9535 {
9536  public:
9537  CImpinjTiltConfiguration (void);
9538  ~CImpinjTiltConfiguration (void);
9539 
9542 
9543  static const CFieldDescriptor * const
9544  s_apFieldDescriptorTable[];
9545 
9546  static const CTypeDescriptor
9547  s_typeDescriptor;
9548 
9549  void
9550  decodeFields (
9551  CDecoderStream * pDecoderStream);
9552 
9553  void
9554  assimilateSubParameters (
9555  CErrorDetails * pError);
9556 
9557  void
9558  encode (
9559  CEncoderStream * pEncoderStream) const;
9560 
9561 
9562  llrp_bool_t
9563  isAllowedIn (
9564  const CTypeDescriptor * pEnclosingElementType) const;
9565 
9566 
9567  static CElement *
9568  s_construct (void);
9569 
9570  static void
9571  s_decodeFields (
9572  CDecoderStream * pDecoderStream,
9573  CElement * pElement);
9575 
9576 
9577  protected:
9578  llrp_s32_t m_XAxis;
9579 
9582  public:
9583  static const CFieldDescriptor
9584  s_fdXAxis;
9586 
9588  inline llrp_s32_t
9589  getXAxis (void)
9590  {
9591  return m_XAxis;
9592  }
9593 
9595  inline void
9597  llrp_s32_t value)
9598  {
9599  m_XAxis = value;
9600  }
9601 
9602 
9603  protected:
9604  llrp_s32_t m_YAxis;
9605 
9608  public:
9609  static const CFieldDescriptor
9610  s_fdYAxis;
9612 
9614  inline llrp_s32_t
9615  getYAxis (void)
9616  {
9617  return m_YAxis;
9618  }
9619 
9621  inline void
9623  llrp_s32_t value)
9624  {
9625  m_YAxis = value;
9626  }
9627 
9628 
9629  protected:
9630  llrp_s32_t m_ZAxis;
9631 
9634  public:
9635  static const CFieldDescriptor
9636  s_fdZAxis;
9638 
9640  inline llrp_s32_t
9641  getZAxis (void)
9642  {
9643  return m_ZAxis;
9644  }
9645 
9647  inline void
9649  llrp_s32_t value)
9650  {
9651  m_ZAxis = value;
9652  }
9653 
9654 
9655 
9656  protected:
9657  std::list<CParameter *> m_listCustom;
9658 
9659  public:
9661  inline std::list<CParameter *>::iterator
9663  {
9664  return m_listCustom.begin();
9665  }
9666 
9668  inline std::list<CParameter *>::iterator
9669  endCustom (void)
9670  {
9671  return m_listCustom.end();
9672  }
9673 
9675  inline void
9677  {
9678  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9679  }
9680 
9682  inline int
9684  {
9685  return (int) (m_listCustom.size());
9686  }
9687 
9688  EResultCode
9690  addCustom (
9691  CParameter * pValue);
9692 
9693 
9694 };
9695 
9696 
9725 class CImpinjBeaconConfiguration : public CParameter
9726 {
9727  public:
9730 
9733 
9734  static const CFieldDescriptor * const
9735  s_apFieldDescriptorTable[];
9736 
9737  static const CTypeDescriptor
9738  s_typeDescriptor;
9739 
9740  void
9741  decodeFields (
9742  CDecoderStream * pDecoderStream);
9743 
9744  void
9745  assimilateSubParameters (
9746  CErrorDetails * pError);
9747 
9748  void
9749  encode (
9750  CEncoderStream * pEncoderStream) const;
9751 
9752 
9753  llrp_bool_t
9754  isAllowedIn (
9755  const CTypeDescriptor * pEnclosingElementType) const;
9756 
9757 
9758  static CElement *
9759  s_construct (void);
9760 
9761  static void
9762  s_decodeFields (
9763  CDecoderStream * pDecoderStream,
9764  CElement * pElement);
9766 
9767 
9768  protected:
9769  llrp_u1_t m_BeaconState;
9770 
9773  public:
9774  static const CFieldDescriptor
9775  s_fdBeaconState;
9777 
9779  inline llrp_u1_t
9781  {
9782  return m_BeaconState;
9783  }
9784 
9786  inline void
9788  llrp_u1_t value)
9789  {
9790  m_BeaconState = value;
9791  }
9792 
9793 
9794  protected:
9795  llrp_u64_t m_BeaconDurationSeconds;
9796 
9799  public:
9800  static const CFieldDescriptor
9801  s_fdBeaconDurationSeconds;
9803 
9805  inline llrp_u64_t
9807  {
9808  return m_BeaconDurationSeconds;
9809  }
9810 
9812  inline void
9814  llrp_u64_t value)
9815  {
9816  m_BeaconDurationSeconds = value;
9817  }
9818 
9819 
9820 
9821  protected:
9822  std::list<CParameter *> m_listCustom;
9823 
9824  public:
9826  inline std::list<CParameter *>::iterator
9828  {
9829  return m_listCustom.begin();
9830  }
9831 
9833  inline std::list<CParameter *>::iterator
9834  endCustom (void)
9835  {
9836  return m_listCustom.end();
9837  }
9838 
9840  inline void
9842  {
9843  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9844  }
9845 
9847  inline int
9849  {
9850  return (int) (m_listCustom.size());
9851  }
9852 
9853  EResultCode
9855  addCustom (
9856  CParameter * pValue);
9857 
9858 
9859 };
9860 
9861 
9889 class CImpinjAntennaConfiguration : public CParameter
9890 {
9891  public:
9894 
9897 
9898  static const CFieldDescriptor * const
9899  s_apFieldDescriptorTable[];
9900 
9901  static const CTypeDescriptor
9902  s_typeDescriptor;
9903 
9904  void
9905  decodeFields (
9906  CDecoderStream * pDecoderStream);
9907 
9908  void
9909  assimilateSubParameters (
9910  CErrorDetails * pError);
9911 
9912  void
9913  encode (
9914  CEncoderStream * pEncoderStream) const;
9915 
9916 
9917  llrp_bool_t
9918  isAllowedIn (
9919  const CTypeDescriptor * pEnclosingElementType) const;
9920 
9921 
9922  static CElement *
9923  s_construct (void);
9924 
9925  static void
9926  s_decodeFields (
9927  CDecoderStream * pDecoderStream,
9928  CElement * pElement);
9930 
9931 
9932 
9933  protected:
9934  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9935 
9936  public:
9940  {
9941  return m_pImpinjAntennaEventHysteresis;
9942  }
9943 
9945  EResultCode
9946  setImpinjAntennaEventHysteresis (
9948 
9949 
9950  protected:
9951  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9952 
9953  public:
9957  {
9958  return m_pImpinjAntennaEventConfiguration;
9959  }
9960 
9962  EResultCode
9963  setImpinjAntennaEventConfiguration (
9965 
9966 
9967  protected:
9968  std::list<CParameter *> m_listCustom;
9969 
9970  public:
9972  inline std::list<CParameter *>::iterator
9974  {
9975  return m_listCustom.begin();
9976  }
9977 
9979  inline std::list<CParameter *>::iterator
9980  endCustom (void)
9981  {
9982  return m_listCustom.end();
9983  }
9984 
9986  inline void
9988  {
9989  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9990  }
9991 
9993  inline int
9995  {
9996  return (int) (m_listCustom.size());
9997  }
9998 
9999  EResultCode
10001  addCustom (
10002  CParameter * pValue);
10003 
10004 
10005 };
10006 
10007 
10039 class CImpinjAntennaEventHysteresis : public CParameter
10040 {
10041  public:
10044 
10047 
10048  static const CFieldDescriptor * const
10049  s_apFieldDescriptorTable[];
10050 
10051  static const CTypeDescriptor
10052  s_typeDescriptor;
10053 
10054  void
10055  decodeFields (
10056  CDecoderStream * pDecoderStream);
10057 
10058  void
10059  assimilateSubParameters (
10060  CErrorDetails * pError);
10061 
10062  void
10063  encode (
10064  CEncoderStream * pEncoderStream) const;
10065 
10066 
10067  llrp_bool_t
10068  isAllowedIn (
10069  const CTypeDescriptor * pEnclosingElementType) const;
10070 
10071 
10072  static CElement *
10073  s_construct (void);
10074 
10075  static void
10076  s_decodeFields (
10077  CDecoderStream * pDecoderStream,
10078  CElement * pElement);
10080 
10081 
10082  protected:
10083  llrp_u64_t m_AntennaEventConnected;
10084 
10087  public:
10088  static const CFieldDescriptor
10089  s_fdAntennaEventConnected;
10091 
10093  inline llrp_u64_t
10095  {
10096  return m_AntennaEventConnected;
10097  }
10098 
10100  inline void
10102  llrp_u64_t value)
10103  {
10104  m_AntennaEventConnected = value;
10105  }
10106 
10107 
10108  protected:
10109  llrp_u64_t m_AntennaEventDisconnected;
10110 
10113  public:
10114  static const CFieldDescriptor
10115  s_fdAntennaEventDisconnected;
10117 
10119  inline llrp_u64_t
10121  {
10122  return m_AntennaEventDisconnected;
10123  }
10124 
10126  inline void
10128  llrp_u64_t value)
10129  {
10130  m_AntennaEventDisconnected = value;
10131  }
10132 
10133 
10134 
10135  protected:
10136  std::list<CParameter *> m_listCustom;
10137 
10138  public:
10140  inline std::list<CParameter *>::iterator
10142  {
10143  return m_listCustom.begin();
10144  }
10145 
10147  inline std::list<CParameter *>::iterator
10148  endCustom (void)
10149  {
10150  return m_listCustom.end();
10151  }
10152 
10154  inline void
10156  {
10157  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10158  }
10159 
10161  inline int
10163  {
10164  return (int) (m_listCustom.size());
10165  }
10166 
10167  EResultCode
10169  addCustom (
10170  CParameter * pValue);
10171 
10172 
10173 };
10174 
10175 
10201 class CImpinjAntennaEventConfiguration : public CParameter
10202 {
10203  public:
10206 
10209 
10210  static const CFieldDescriptor * const
10211  s_apFieldDescriptorTable[];
10212 
10213  static const CTypeDescriptor
10214  s_typeDescriptor;
10215 
10216  void
10217  decodeFields (
10218  CDecoderStream * pDecoderStream);
10219 
10220  void
10221  assimilateSubParameters (
10222  CErrorDetails * pError);
10223 
10224  void
10225  encode (
10226  CEncoderStream * pEncoderStream) const;
10227 
10228 
10229  llrp_bool_t
10230  isAllowedIn (
10231  const CTypeDescriptor * pEnclosingElementType) const;
10232 
10233 
10234  static CElement *
10235  s_construct (void);
10236 
10237  static void
10238  s_decodeFields (
10239  CDecoderStream * pDecoderStream,
10240  CElement * pElement);
10242 
10243 
10244  protected:
10245  llrp_u1_t m_EnableAntennaAttemptNotification;
10246 
10249  public:
10250  static const CFieldDescriptor
10251  s_fdEnableAntennaAttemptNotification;
10253 
10255  inline llrp_u1_t
10257  {
10258  return m_EnableAntennaAttemptNotification;
10259  }
10260 
10262  inline void
10264  llrp_u1_t value)
10265  {
10266  m_EnableAntennaAttemptNotification = value;
10267  }
10268 
10269 
10270 
10271  protected:
10272  std::list<CParameter *> m_listCustom;
10273 
10274  public:
10276  inline std::list<CParameter *>::iterator
10278  {
10279  return m_listCustom.begin();
10280  }
10281 
10283  inline std::list<CParameter *>::iterator
10284  endCustom (void)
10285  {
10286  return m_listCustom.end();
10287  }
10288 
10290  inline void
10292  {
10293  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10294  }
10295 
10297  inline int
10299  {
10300  return (int) (m_listCustom.size());
10301  }
10302 
10303  EResultCode
10305  addCustom (
10306  CParameter * pValue);
10307 
10308 
10309 };
10310 
10311 
10336 class CImpinjAntennaAttemptEvent : public CParameter
10337 {
10338  public:
10341 
10344 
10345  static const CFieldDescriptor * const
10346  s_apFieldDescriptorTable[];
10347 
10348  static const CTypeDescriptor
10349  s_typeDescriptor;
10350 
10351  void
10352  decodeFields (
10353  CDecoderStream * pDecoderStream);
10354 
10355  void
10356  assimilateSubParameters (
10357  CErrorDetails * pError);
10358 
10359  void
10360  encode (
10361  CEncoderStream * pEncoderStream) const;
10362 
10363 
10364  llrp_bool_t
10365  isAllowedIn (
10366  const CTypeDescriptor * pEnclosingElementType) const;
10367 
10368 
10369  static CElement *
10370  s_construct (void);
10371 
10372  static void
10373  s_decodeFields (
10374  CDecoderStream * pDecoderStream,
10375  CElement * pElement);
10377 
10378 
10379  protected:
10380  llrp_u16_t m_AntennaID;
10381 
10384  public:
10385  static const CFieldDescriptor
10386  s_fdAntennaID;
10388 
10390  inline llrp_u16_t
10392  {
10393  return m_AntennaID;
10394  }
10395 
10397  inline void
10399  llrp_u16_t value)
10400  {
10401  m_AntennaID = value;
10402  }
10403 
10404 
10405 
10406  protected:
10407  std::list<CParameter *> m_listCustom;
10408 
10409  public:
10411  inline std::list<CParameter *>::iterator
10413  {
10414  return m_listCustom.begin();
10415  }
10416 
10418  inline std::list<CParameter *>::iterator
10419  endCustom (void)
10420  {
10421  return m_listCustom.end();
10422  }
10423 
10425  inline void
10427  {
10428  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10429  }
10430 
10432  inline int
10434  {
10435  return (int) (m_listCustom.size());
10436  }
10437 
10438  EResultCode
10440  addCustom (
10441  CParameter * pValue);
10442 
10443 
10444 };
10445 
10446 
10474 class CImpinjHubConfiguration : public CParameter
10475 {
10476  public:
10477  CImpinjHubConfiguration (void);
10478  ~CImpinjHubConfiguration (void);
10479 
10482 
10483  static const CFieldDescriptor * const
10484  s_apFieldDescriptorTable[];
10485 
10486  static const CTypeDescriptor
10487  s_typeDescriptor;
10488 
10489  void
10490  decodeFields (
10491  CDecoderStream * pDecoderStream);
10492 
10493  void
10494  assimilateSubParameters (
10495  CErrorDetails * pError);
10496 
10497  void
10498  encode (
10499  CEncoderStream * pEncoderStream) const;
10500 
10501 
10502  llrp_bool_t
10503  isAllowedIn (
10504  const CTypeDescriptor * pEnclosingElementType) const;
10505 
10506 
10507  static CElement *
10508  s_construct (void);
10509 
10510  static void
10511  s_decodeFields (
10512  CDecoderStream * pDecoderStream,
10513  CElement * pElement);
10515 
10516 
10517  protected:
10518  llrp_u16_t m_HubID;
10519 
10522  public:
10523  static const CFieldDescriptor
10524  s_fdHubID;
10526 
10528  inline llrp_u16_t
10529  getHubID (void)
10530  {
10531  return m_HubID;
10532  }
10533 
10535  inline void
10537  llrp_u16_t value)
10538  {
10539  m_HubID = value;
10540  }
10541 
10542 
10543  protected:
10544  EImpinjHubConnectedType m_eConnected;
10545 
10548  public:
10549  static const CFieldDescriptor
10550  s_fdConnected;
10552 
10554  inline EImpinjHubConnectedType
10556  {
10557  return m_eConnected;
10558  }
10559 
10561  inline void
10563  EImpinjHubConnectedType value)
10564  {
10565  m_eConnected = value;
10566  }
10567 
10568 
10569  protected:
10570  EImpinjHubFaultType m_eFault;
10571 
10574  public:
10575  static const CFieldDescriptor
10576  s_fdFault;
10578 
10580  inline EImpinjHubFaultType
10581  getFault (void)
10582  {
10583  return m_eFault;
10584  }
10585 
10587  inline void
10589  EImpinjHubFaultType value)
10590  {
10591  m_eFault = value;
10592  }
10593 
10594 
10595 
10596  protected:
10597  std::list<CParameter *> m_listCustom;
10598 
10599  public:
10601  inline std::list<CParameter *>::iterator
10603  {
10604  return m_listCustom.begin();
10605  }
10606 
10608  inline std::list<CParameter *>::iterator
10609  endCustom (void)
10610  {
10611  return m_listCustom.end();
10612  }
10613 
10615  inline void
10617  {
10618  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10619  }
10620 
10622  inline int
10624  {
10625  return (int) (m_listCustom.size());
10626  }
10627 
10628  EResultCode
10630  addCustom (
10631  CParameter * pValue);
10632 
10633 
10634 };
10635 
10636 
10660 class CImpinjDiagnosticReport : public CParameter
10661 {
10662  public:
10663  CImpinjDiagnosticReport (void);
10664  ~CImpinjDiagnosticReport (void);
10665 
10668 
10669  static const CFieldDescriptor * const
10670  s_apFieldDescriptorTable[];
10671 
10672  static const CTypeDescriptor
10673  s_typeDescriptor;
10674 
10675  void
10676  decodeFields (
10677  CDecoderStream * pDecoderStream);
10678 
10679  void
10680  assimilateSubParameters (
10681  CErrorDetails * pError);
10682 
10683  void
10684  encode (
10685  CEncoderStream * pEncoderStream) const;
10686 
10687 
10688  llrp_bool_t
10689  isAllowedIn (
10690  const CTypeDescriptor * pEnclosingElementType) const;
10691 
10692 
10693  static CElement *
10694  s_construct (void);
10695 
10696  static void
10697  s_decodeFields (
10698  CDecoderStream * pDecoderStream,
10699  CElement * pElement);
10701 
10702 
10703  protected:
10704  llrp_u32v_t m_Metric;
10705 
10708  public:
10709  static const CFieldDescriptor
10710  s_fdMetric;
10712 
10714  inline llrp_u32v_t
10715  getMetric (void)
10716  {
10717  return m_Metric;
10718  }
10719 
10721  inline void
10723  llrp_u32v_t value)
10724  {
10725  m_Metric = value;
10726  }
10727 
10728 
10729 
10730 };
10731 
10732 
10771 class CImpinjPlacementConfiguration : public CParameter
10772 {
10773  public:
10776 
10779 
10780  static const CFieldDescriptor * const
10781  s_apFieldDescriptorTable[];
10782 
10783  static const CTypeDescriptor
10784  s_typeDescriptor;
10785 
10786  void
10787  decodeFields (
10788  CDecoderStream * pDecoderStream);
10789 
10790  void
10791  assimilateSubParameters (
10792  CErrorDetails * pError);
10793 
10794  void
10795  encode (
10796  CEncoderStream * pEncoderStream) const;
10797 
10798 
10799  llrp_bool_t
10800  isAllowedIn (
10801  const CTypeDescriptor * pEnclosingElementType) const;
10802 
10803 
10804  static CElement *
10805  s_construct (void);
10806 
10807  static void
10808  s_decodeFields (
10809  CDecoderStream * pDecoderStream,
10810  CElement * pElement);
10812 
10813 
10814  protected:
10815  llrp_u16_t m_HeightCm;
10816 
10819  public:
10820  static const CFieldDescriptor
10821  s_fdHeightCm;
10823 
10825  inline llrp_u16_t
10827  {
10828  return m_HeightCm;
10829  }
10830 
10832  inline void
10834  llrp_u16_t value)
10835  {
10836  m_HeightCm = value;
10837  }
10838 
10839 
10840  protected:
10841  llrp_s32_t m_FacilityXLocationCm;
10842 
10845  public:
10846  static const CFieldDescriptor
10847  s_fdFacilityXLocationCm;
10849 
10851  inline llrp_s32_t
10853  {
10854  return m_FacilityXLocationCm;
10855  }
10856 
10858  inline void
10860  llrp_s32_t value)
10861  {
10862  m_FacilityXLocationCm = value;
10863  }
10864 
10865 
10866  protected:
10867  llrp_s32_t m_FacilityYLocationCm;
10868 
10871  public:
10872  static const CFieldDescriptor
10873  s_fdFacilityYLocationCm;
10875 
10877  inline llrp_s32_t
10879  {
10880  return m_FacilityYLocationCm;
10881  }
10882 
10884  inline void
10886  llrp_s32_t value)
10887  {
10888  m_FacilityYLocationCm = value;
10889  }
10890 
10891 
10892  protected:
10893  llrp_s16_t m_OrientationDegrees;
10894 
10897  public:
10898  static const CFieldDescriptor
10899  s_fdOrientationDegrees;
10901 
10903  inline llrp_s16_t
10905  {
10906  return m_OrientationDegrees;
10907  }
10908 
10910  inline void
10912  llrp_s16_t value)
10913  {
10914  m_OrientationDegrees = value;
10915  }
10916 
10917 
10918 
10919  protected:
10920  std::list<CParameter *> m_listCustom;
10921 
10922  public:
10924  inline std::list<CParameter *>::iterator
10926  {
10927  return m_listCustom.begin();
10928  }
10929 
10931  inline std::list<CParameter *>::iterator
10932  endCustom (void)
10933  {
10934  return m_listCustom.end();
10935  }
10936 
10938  inline void
10940  {
10941  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10942  }
10943 
10945  inline int
10947  {
10948  return (int) (m_listCustom.size());
10949  }
10950 
10951  EResultCode
10953  addCustom (
10954  CParameter * pValue);
10955 
10956 
10957 };
10958 
10959 
10990 class CImpinjLISpec : public CParameter
10991 {
10992  public:
10993  CImpinjLISpec (void);
10994  ~CImpinjLISpec (void);
10995 
10998 
10999  static const CFieldDescriptor * const
11000  s_apFieldDescriptorTable[];
11001 
11002  static const CTypeDescriptor
11003  s_typeDescriptor;
11004 
11005  void
11006  decodeFields (
11007  CDecoderStream * pDecoderStream);
11008 
11009  void
11010  assimilateSubParameters (
11011  CErrorDetails * pError);
11012 
11013  void
11014  encode (
11015  CEncoderStream * pEncoderStream) const;
11016 
11017 
11018  llrp_bool_t
11019  isAllowedIn (
11020  const CTypeDescriptor * pEnclosingElementType) const;
11021 
11022 
11023  static CElement *
11024  s_construct (void);
11025 
11026  static void
11027  s_decodeFields (
11028  CDecoderStream * pDecoderStream,
11029  CElement * pElement);
11031 
11032 
11033 
11034  protected:
11035  CImpinjLocationConfig * m_pImpinjLocationConfig;
11036 
11037  public:
11039  inline CImpinjLocationConfig *
11041  {
11042  return m_pImpinjLocationConfig;
11043  }
11044 
11046  EResultCode
11047  setImpinjLocationConfig (
11048  CImpinjLocationConfig * pValue);
11049 
11050 
11051  protected:
11052  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
11053 
11054  public:
11056  inline CImpinjC1G2LocationConfig *
11058  {
11059  return m_pImpinjC1G2LocationConfig;
11060  }
11061 
11063  EResultCode
11064  setImpinjC1G2LocationConfig (
11065  CImpinjC1G2LocationConfig * pValue);
11066 
11067 
11068  protected:
11069  CImpinjLocationReporting * m_pImpinjLocationReporting;
11070 
11071  public:
11073  inline CImpinjLocationReporting *
11075  {
11076  return m_pImpinjLocationReporting;
11077  }
11078 
11080  EResultCode
11081  setImpinjLocationReporting (
11082  CImpinjLocationReporting * pValue);
11083 
11084 
11085  protected:
11086  std::list<CParameter *> m_listCustom;
11087 
11088  public:
11090  inline std::list<CParameter *>::iterator
11092  {
11093  return m_listCustom.begin();
11094  }
11095 
11097  inline std::list<CParameter *>::iterator
11098  endCustom (void)
11099  {
11100  return m_listCustom.end();
11101  }
11102 
11104  inline void
11106  {
11107  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11108  }
11109 
11111  inline int
11113  {
11114  return (int) (m_listCustom.size());
11115  }
11116 
11117  EResultCode
11119  addCustom (
11120  CParameter * pValue);
11121 
11122 
11123 };
11124 
11125 
11171 class CImpinjLocationConfig : public CParameter
11172 {
11173  public:
11174  CImpinjLocationConfig (void);
11175  ~CImpinjLocationConfig (void);
11176 
11179 
11180  static const CFieldDescriptor * const
11181  s_apFieldDescriptorTable[];
11182 
11183  static const CTypeDescriptor
11184  s_typeDescriptor;
11185 
11186  void
11187  decodeFields (
11188  CDecoderStream * pDecoderStream);
11189 
11190  void
11191  assimilateSubParameters (
11192  CErrorDetails * pError);
11193 
11194  void
11195  encode (
11196  CEncoderStream * pEncoderStream) const;
11197 
11198 
11199  llrp_bool_t
11200  isAllowedIn (
11201  const CTypeDescriptor * pEnclosingElementType) const;
11202 
11203 
11204  static CElement *
11205  s_construct (void);
11206 
11207  static void
11208  s_decodeFields (
11209  CDecoderStream * pDecoderStream,
11210  CElement * pElement);
11212 
11213 
11214  protected:
11215  llrp_u16_t m_ComputeWindowSeconds;
11216 
11219  public:
11220  static const CFieldDescriptor
11221  s_fdComputeWindowSeconds;
11223 
11225  inline llrp_u16_t
11227  {
11228  return m_ComputeWindowSeconds;
11229  }
11230 
11232  inline void
11234  llrp_u16_t value)
11235  {
11236  m_ComputeWindowSeconds = value;
11237  }
11238 
11239 
11240  protected:
11241  llrp_u16_t m_TagAgeIntervalSeconds;
11242 
11245  public:
11246  static const CFieldDescriptor
11247  s_fdTagAgeIntervalSeconds;
11249 
11251  inline llrp_u16_t
11253  {
11254  return m_TagAgeIntervalSeconds;
11255  }
11256 
11258  inline void
11260  llrp_u16_t value)
11261  {
11262  m_TagAgeIntervalSeconds = value;
11263  }
11264 
11265 
11266  protected:
11267  llrp_u16_t m_UpdateIntervalSeconds;
11268 
11271  public:
11272  static const CFieldDescriptor
11273  s_fdUpdateIntervalSeconds;
11275 
11277  inline llrp_u16_t
11279  {
11280  return m_UpdateIntervalSeconds;
11281  }
11282 
11284  inline void
11286  llrp_u16_t value)
11287  {
11288  m_UpdateIntervalSeconds = value;
11289  }
11290 
11291 
11292 
11293  protected:
11294  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
11295 
11296  public:
11298  inline CImpinjDisabledAntennas *
11300  {
11301  return m_pImpinjDisabledAntennas;
11302  }
11303 
11305  EResultCode
11306  setImpinjDisabledAntennas (
11307  CImpinjDisabledAntennas * pValue);
11308 
11309 
11310  protected:
11311  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
11312 
11313  public:
11317  {
11318  return m_pImpinjLocationAlgorithmControl;
11319  }
11320 
11322  EResultCode
11323  setImpinjLocationAlgorithmControl (
11325 
11326 
11327  protected:
11328  std::list<CParameter *> m_listCustom;
11329 
11330  public:
11332  inline std::list<CParameter *>::iterator
11334  {
11335  return m_listCustom.begin();
11336  }
11337 
11339  inline std::list<CParameter *>::iterator
11340  endCustom (void)
11341  {
11342  return m_listCustom.end();
11343  }
11344 
11346  inline void
11348  {
11349  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11350  }
11351 
11353  inline int
11355  {
11356  return (int) (m_listCustom.size());
11357  }
11358 
11359  EResultCode
11361  addCustom (
11362  CParameter * pValue);
11363 
11364 
11365 };
11366 
11367 
11410 class CImpinjC1G2LocationConfig : public CParameter
11411 {
11412  public:
11414  ~CImpinjC1G2LocationConfig (void);
11415 
11418 
11419  static const CFieldDescriptor * const
11420  s_apFieldDescriptorTable[];
11421 
11422  static const CTypeDescriptor
11423  s_typeDescriptor;
11424 
11425  void
11426  decodeFields (
11427  CDecoderStream * pDecoderStream);
11428 
11429  void
11430  assimilateSubParameters (
11431  CErrorDetails * pError);
11432 
11433  void
11434  encode (
11435  CEncoderStream * pEncoderStream) const;
11436 
11437 
11438  llrp_bool_t
11439  isAllowedIn (
11440  const CTypeDescriptor * pEnclosingElementType) const;
11441 
11442 
11443  static CElement *
11444  s_construct (void);
11445 
11446  static void
11447  s_decodeFields (
11448  CDecoderStream * pDecoderStream,
11449  CElement * pElement);
11451 
11452 
11453  protected:
11454  llrp_u16_t m_ModeIndex;
11455 
11458  public:
11459  static const CFieldDescriptor
11460  s_fdModeIndex;
11462 
11464  inline llrp_u16_t
11466  {
11467  return m_ModeIndex;
11468  }
11469 
11471  inline void
11473  llrp_u16_t value)
11474  {
11475  m_ModeIndex = value;
11476  }
11477 
11478 
11479  protected:
11480  llrp_u2_t m_Session;
11481 
11484  public:
11485  static const CFieldDescriptor
11486  s_fdSession;
11488 
11490  inline llrp_u2_t
11491  getSession (void)
11492  {
11493  return m_Session;
11494  }
11495 
11497  inline void
11499  llrp_u2_t value)
11500  {
11501  m_Session = value;
11502  }
11503 
11504 
11505 
11506  protected:
11507  std::list<CC1G2Filter *> m_listC1G2Filter;
11508 
11509  public:
11511  inline std::list<CC1G2Filter *>::iterator
11513  {
11514  return m_listC1G2Filter.begin();
11515  }
11516 
11518  inline std::list<CC1G2Filter *>::iterator
11520  {
11521  return m_listC1G2Filter.end();
11522  }
11523 
11525  inline void
11527  {
11528  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
11529  }
11530 
11532  inline int
11534  {
11535  return (int) (m_listC1G2Filter.size());
11536  }
11537 
11538  EResultCode
11540  addC1G2Filter (
11541  CC1G2Filter * pValue);
11542 
11543 
11544  protected:
11545  CImpinjTransmitPower * m_pImpinjTransmitPower;
11546 
11547  public:
11549  inline CImpinjTransmitPower *
11551  {
11552  return m_pImpinjTransmitPower;
11553  }
11554 
11556  EResultCode
11557  setImpinjTransmitPower (
11558  CImpinjTransmitPower * pValue);
11559 
11560 
11561  protected:
11562  std::list<CParameter *> m_listCustom;
11563 
11564  public:
11566  inline std::list<CParameter *>::iterator
11568  {
11569  return m_listCustom.begin();
11570  }
11571 
11573  inline std::list<CParameter *>::iterator
11574  endCustom (void)
11575  {
11576  return m_listCustom.end();
11577  }
11578 
11580  inline void
11582  {
11583  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11584  }
11585 
11587  inline int
11589  {
11590  return (int) (m_listCustom.size());
11591  }
11592 
11593  EResultCode
11595  addCustom (
11596  CParameter * pValue);
11597 
11598 
11599 };
11600 
11601 
11643 class CImpinjLocationReporting : public CParameter
11644 {
11645  public:
11646  CImpinjLocationReporting (void);
11647  ~CImpinjLocationReporting (void);
11648 
11651 
11652  static const CFieldDescriptor * const
11653  s_apFieldDescriptorTable[];
11654 
11655  static const CTypeDescriptor
11656  s_typeDescriptor;
11657 
11658  void
11659  decodeFields (
11660  CDecoderStream * pDecoderStream);
11661 
11662  void
11663  assimilateSubParameters (
11664  CErrorDetails * pError);
11665 
11666  void
11667  encode (
11668  CEncoderStream * pEncoderStream) const;
11669 
11670 
11671  llrp_bool_t
11672  isAllowedIn (
11673  const CTypeDescriptor * pEnclosingElementType) const;
11674 
11675 
11676  static CElement *
11677  s_construct (void);
11678 
11679  static void
11680  s_decodeFields (
11681  CDecoderStream * pDecoderStream,
11682  CElement * pElement);
11684 
11685 
11686  protected:
11687  llrp_u1_t m_EnableUpdateReport;
11688 
11691  public:
11692  static const CFieldDescriptor
11693  s_fdEnableUpdateReport;
11695 
11697  inline llrp_u1_t
11699  {
11700  return m_EnableUpdateReport;
11701  }
11702 
11704  inline void
11706  llrp_u1_t value)
11707  {
11708  m_EnableUpdateReport = value;
11709  }
11710 
11711 
11712  protected:
11713  llrp_u1_t m_EnableEntryReport;
11714 
11717  public:
11718  static const CFieldDescriptor
11719  s_fdEnableEntryReport;
11721 
11723  inline llrp_u1_t
11725  {
11726  return m_EnableEntryReport;
11727  }
11728 
11730  inline void
11732  llrp_u1_t value)
11733  {
11734  m_EnableEntryReport = value;
11735  }
11736 
11737 
11738  protected:
11739  llrp_u1_t m_EnableExitReport;
11740 
11743  public:
11744  static const CFieldDescriptor
11745  s_fdEnableExitReport;
11747 
11749  inline llrp_u1_t
11751  {
11752  return m_EnableExitReport;
11753  }
11754 
11756  inline void
11758  llrp_u1_t value)
11759  {
11760  m_EnableExitReport = value;
11761  }
11762 
11763 
11764  protected:
11765  llrp_u1_t m_EnableDiagnosticReport;
11766 
11769  public:
11770  static const CFieldDescriptor
11771  s_fdEnableDiagnosticReport;
11773 
11775  inline llrp_u1_t
11777  {
11778  return m_EnableDiagnosticReport;
11779  }
11780 
11782  inline void
11784  llrp_u1_t value)
11785  {
11786  m_EnableDiagnosticReport = value;
11787  }
11788 
11789 
11790 
11791  protected:
11792  std::list<CParameter *> m_listCustom;
11793 
11794  public:
11796  inline std::list<CParameter *>::iterator
11798  {
11799  return m_listCustom.begin();
11800  }
11801 
11803  inline std::list<CParameter *>::iterator
11804  endCustom (void)
11805  {
11806  return m_listCustom.end();
11807  }
11808 
11810  inline void
11812  {
11813  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11814  }
11815 
11817  inline int
11819  {
11820  return (int) (m_listCustom.size());
11821  }
11822 
11823  EResultCode
11825  addCustom (
11826  CParameter * pValue);
11827 
11828 
11829 };
11830 
11831 
11862 class CImpinjLocationConfidence : public CParameter
11863 {
11864  public:
11866  ~CImpinjLocationConfidence (void);
11867 
11870 
11871  static const CFieldDescriptor * const
11872  s_apFieldDescriptorTable[];
11873 
11874  static const CTypeDescriptor
11875  s_typeDescriptor;
11876 
11877  void
11878  decodeFields (
11879  CDecoderStream * pDecoderStream);
11880 
11881  void
11882  assimilateSubParameters (
11883  CErrorDetails * pError);
11884 
11885  void
11886  encode (
11887  CEncoderStream * pEncoderStream) const;
11888 
11889 
11890  llrp_bool_t
11891  isAllowedIn (
11892  const CTypeDescriptor * pEnclosingElementType) const;
11893 
11894 
11895  static CElement *
11896  s_construct (void);
11897 
11898  static void
11899  s_decodeFields (
11900  CDecoderStream * pDecoderStream,
11901  CElement * pElement);
11903 
11904 
11905  protected:
11906  llrp_u16_t m_ReadCount;
11907 
11910  public:
11911  static const CFieldDescriptor
11912  s_fdReadCount;
11914 
11916  inline llrp_u16_t
11918  {
11919  return m_ReadCount;
11920  }
11921 
11923  inline void
11925  llrp_u16_t value)
11926  {
11927  m_ReadCount = value;
11928  }
11929 
11930 
11931  protected:
11932  llrp_u32v_t m_ConfidenceData;
11933 
11936  public:
11937  static const CFieldDescriptor
11938  s_fdConfidenceData;
11940 
11942  inline llrp_u32v_t
11944  {
11945  return m_ConfidenceData;
11946  }
11947 
11949  inline void
11951  llrp_u32v_t value)
11952  {
11953  m_ConfidenceData = value;
11954  }
11955 
11956 
11957 
11958  protected:
11959  std::list<CParameter *> m_listCustom;
11960 
11961  public:
11963  inline std::list<CParameter *>::iterator
11965  {
11966  return m_listCustom.begin();
11967  }
11968 
11970  inline std::list<CParameter *>::iterator
11971  endCustom (void)
11972  {
11973  return m_listCustom.end();
11974  }
11975 
11977  inline void
11979  {
11980  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11981  }
11982 
11984  inline int
11986  {
11987  return (int) (m_listCustom.size());
11988  }
11989 
11990  EResultCode
11992  addCustom (
11993  CParameter * pValue);
11994 
11995 
11996 };
11997 
11998 
12036 class CImpinjLocationReportData : public CParameter
12037 {
12038  public:
12040  ~CImpinjLocationReportData (void);
12041 
12044 
12045  static const CFieldDescriptor * const
12046  s_apFieldDescriptorTable[];
12047 
12048  static const CTypeDescriptor
12049  s_typeDescriptor;
12050 
12051  void
12052  decodeFields (
12053  CDecoderStream * pDecoderStream);
12054 
12055  void
12056  assimilateSubParameters (
12057  CErrorDetails * pError);
12058 
12059  void
12060  encode (
12061  CEncoderStream * pEncoderStream) const;
12062 
12063 
12064  llrp_bool_t
12065  isAllowedIn (
12066  const CTypeDescriptor * pEnclosingElementType) const;
12067 
12068 
12069  static CElement *
12070  s_construct (void);
12071 
12072  static void
12073  s_decodeFields (
12074  CDecoderStream * pDecoderStream,
12075  CElement * pElement);
12077 
12078 
12079  protected:
12080  llrp_u64_t m_LastSeenTimestampUTC;
12081 
12084  public:
12085  static const CFieldDescriptor
12086  s_fdLastSeenTimestampUTC;
12088 
12090  inline llrp_u64_t
12092  {
12093  return m_LastSeenTimestampUTC;
12094  }
12095 
12097  inline void
12099  llrp_u64_t value)
12100  {
12101  m_LastSeenTimestampUTC = value;
12102  }
12103 
12104 
12105  protected:
12106  llrp_s32_t m_LocXCentimeters;
12107 
12110  public:
12111  static const CFieldDescriptor
12112  s_fdLocXCentimeters;
12114 
12116  inline llrp_s32_t
12118  {
12119  return m_LocXCentimeters;
12120  }
12121 
12123  inline void
12125  llrp_s32_t value)
12126  {
12127  m_LocXCentimeters = value;
12128  }
12129 
12130 
12131  protected:
12132  llrp_s32_t m_LocYCentimeters;
12133 
12136  public:
12137  static const CFieldDescriptor
12138  s_fdLocYCentimeters;
12140 
12142  inline llrp_s32_t
12144  {
12145  return m_LocYCentimeters;
12146  }
12147 
12149  inline void
12151  llrp_s32_t value)
12152  {
12153  m_LocYCentimeters = value;
12154  }
12155 
12156 
12157  protected:
12158  EImpinjLocationReportType m_eType;
12159 
12162  public:
12163  static const CFieldDescriptor
12164  s_fdType;
12166 
12168  inline EImpinjLocationReportType
12169  getType (void)
12170  {
12171  return m_eType;
12172  }
12173 
12175  inline void
12177  EImpinjLocationReportType value)
12178  {
12179  m_eType = value;
12180  }
12181 
12182 
12183 
12184  protected:
12185  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
12186 
12187  public:
12189  inline CImpinjLocationConfidence *
12191  {
12192  return m_pImpinjLocationConfidence;
12193  }
12194 
12196  EResultCode
12197  setImpinjLocationConfidence (
12198  CImpinjLocationConfidence * pValue);
12199 
12200 
12201  protected:
12202  std::list<CParameter *> m_listCustom;
12203 
12204  public:
12206  inline std::list<CParameter *>::iterator
12208  {
12209  return m_listCustom.begin();
12210  }
12211 
12213  inline std::list<CParameter *>::iterator
12214  endCustom (void)
12215  {
12216  return m_listCustom.end();
12217  }
12218 
12220  inline void
12222  {
12223  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12224  }
12225 
12227  inline int
12229  {
12230  return (int) (m_listCustom.size());
12231  }
12232 
12233  EResultCode
12235  addCustom (
12236  CParameter * pValue);
12237 
12238 
12239 };
12240 
12241 
12274 class CImpinjDISpec : public CParameter
12275 {
12276  public:
12277  CImpinjDISpec (void);
12278  ~CImpinjDISpec (void);
12279 
12282 
12283  static const CFieldDescriptor * const
12284  s_apFieldDescriptorTable[];
12285 
12286  static const CTypeDescriptor
12287  s_typeDescriptor;
12288 
12289  void
12290  decodeFields (
12291  CDecoderStream * pDecoderStream);
12292 
12293  void
12294  assimilateSubParameters (
12295  CErrorDetails * pError);
12296 
12297  void
12298  encode (
12299  CEncoderStream * pEncoderStream) const;
12300 
12301 
12302  llrp_bool_t
12303  isAllowedIn (
12304  const CTypeDescriptor * pEnclosingElementType) const;
12305 
12306 
12307  static CElement *
12308  s_construct (void);
12309 
12310  static void
12311  s_decodeFields (
12312  CDecoderStream * pDecoderStream,
12313  CElement * pElement);
12315 
12316 
12317 
12318  protected:
12319  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
12320 
12321  public:
12323  inline CImpinjDirectionSectors *
12325  {
12326  return m_pImpinjDirectionSectors;
12327  }
12328 
12330  EResultCode
12331  setImpinjDirectionSectors (
12332  CImpinjDirectionSectors * pValue);
12333 
12334 
12335  protected:
12336  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
12337 
12338  public:
12340  inline CImpinjDirectionConfig *
12342  {
12343  return m_pImpinjDirectionConfig;
12344  }
12345 
12347  EResultCode
12348  setImpinjDirectionConfig (
12349  CImpinjDirectionConfig * pValue);
12350 
12351 
12352  protected:
12353  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
12354 
12355  public:
12359  {
12360  return m_pImpinjC1G2DirectionConfig;
12361  }
12362 
12364  EResultCode
12365  setImpinjC1G2DirectionConfig (
12366  CImpinjC1G2DirectionConfig * pValue);
12367 
12368 
12369  protected:
12370  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
12371 
12372  public:
12374  inline CImpinjDirectionReporting *
12376  {
12377  return m_pImpinjDirectionReporting;
12378  }
12379 
12381  EResultCode
12382  setImpinjDirectionReporting (
12383  CImpinjDirectionReporting * pValue);
12384 
12385 
12386  protected:
12387  std::list<CParameter *> m_listCustom;
12388 
12389  public:
12391  inline std::list<CParameter *>::iterator
12393  {
12394  return m_listCustom.begin();
12395  }
12396 
12398  inline std::list<CParameter *>::iterator
12399  endCustom (void)
12400  {
12401  return m_listCustom.end();
12402  }
12403 
12405  inline void
12407  {
12408  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12409  }
12410 
12412  inline int
12414  {
12415  return (int) (m_listCustom.size());
12416  }
12417 
12418  EResultCode
12420  addCustom (
12421  CParameter * pValue);
12422 
12423 
12424 };
12425 
12426 
12454 class CImpinjDirectionSectors : public CParameter
12455 {
12456  public:
12457  CImpinjDirectionSectors (void);
12458  ~CImpinjDirectionSectors (void);
12459 
12462 
12463  static const CFieldDescriptor * const
12464  s_apFieldDescriptorTable[];
12465 
12466  static const CTypeDescriptor
12467  s_typeDescriptor;
12468 
12469  void
12470  decodeFields (
12471  CDecoderStream * pDecoderStream);
12472 
12473  void
12474  assimilateSubParameters (
12475  CErrorDetails * pError);
12476 
12477  void
12478  encode (
12479  CEncoderStream * pEncoderStream) const;
12480 
12481 
12482  llrp_bool_t
12483  isAllowedIn (
12484  const CTypeDescriptor * pEnclosingElementType) const;
12485 
12486 
12487  static CElement *
12488  s_construct (void);
12489 
12490  static void
12491  s_decodeFields (
12492  CDecoderStream * pDecoderStream,
12493  CElement * pElement);
12495 
12496 
12497  protected:
12498  llrp_u16v_t m_EnabledSectorIDs;
12499 
12502  public:
12503  static const CFieldDescriptor
12504  s_fdEnabledSectorIDs;
12506 
12508  inline llrp_u16v_t
12510  {
12511  return m_EnabledSectorIDs;
12512  }
12513 
12515  inline void
12517  llrp_u16v_t value)
12518  {
12519  m_EnabledSectorIDs = value;
12520  }
12521 
12522 
12523 
12524  protected:
12525  std::list<CParameter *> m_listCustom;
12526 
12527  public:
12529  inline std::list<CParameter *>::iterator
12531  {
12532  return m_listCustom.begin();
12533  }
12534 
12536  inline std::list<CParameter *>::iterator
12537  endCustom (void)
12538  {
12539  return m_listCustom.end();
12540  }
12541 
12543  inline void
12545  {
12546  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12547  }
12548 
12550  inline int
12552  {
12553  return (int) (m_listCustom.size());
12554  }
12555 
12556  EResultCode
12558  addCustom (
12559  CParameter * pValue);
12560 
12561 
12562 };
12563 
12564 
12603 class CImpinjDirectionConfig : public CParameter
12604 {
12605  public:
12606  CImpinjDirectionConfig (void);
12607  ~CImpinjDirectionConfig (void);
12608 
12611 
12612  static const CFieldDescriptor * const
12613  s_apFieldDescriptorTable[];
12614 
12615  static const CTypeDescriptor
12616  s_typeDescriptor;
12617 
12618  void
12619  decodeFields (
12620  CDecoderStream * pDecoderStream);
12621 
12622  void
12623  assimilateSubParameters (
12624  CErrorDetails * pError);
12625 
12626  void
12627  encode (
12628  CEncoderStream * pEncoderStream) const;
12629 
12630 
12631  llrp_bool_t
12632  isAllowedIn (
12633  const CTypeDescriptor * pEnclosingElementType) const;
12634 
12635 
12636  static CElement *
12637  s_construct (void);
12638 
12639  static void
12640  s_decodeFields (
12641  CDecoderStream * pDecoderStream,
12642  CElement * pElement);
12644 
12645 
12646  protected:
12647  llrp_u16_t m_TagAgeIntervalSeconds;
12648 
12651  public:
12652  static const CFieldDescriptor
12653  s_fdTagAgeIntervalSeconds;
12655 
12657  inline llrp_u16_t
12659  {
12660  return m_TagAgeIntervalSeconds;
12661  }
12662 
12664  inline void
12666  llrp_u16_t value)
12667  {
12668  m_TagAgeIntervalSeconds = value;
12669  }
12670 
12671 
12672  protected:
12673  llrp_u16_t m_UpdateIntervalSeconds;
12674 
12677  public:
12678  static const CFieldDescriptor
12679  s_fdUpdateIntervalSeconds;
12681 
12683  inline llrp_u16_t
12685  {
12686  return m_UpdateIntervalSeconds;
12687  }
12688 
12690  inline void
12692  llrp_u16_t value)
12693  {
12694  m_UpdateIntervalSeconds = value;
12695  }
12696 
12697 
12698  protected:
12699  EImpinjDirectionFieldOfView m_eFieldOfView;
12700 
12703  public:
12704  static const CFieldDescriptor
12705  s_fdFieldOfView;
12707 
12709  inline EImpinjDirectionFieldOfView
12711  {
12712  return m_eFieldOfView;
12713  }
12714 
12716  inline void
12718  EImpinjDirectionFieldOfView value)
12719  {
12720  m_eFieldOfView = value;
12721  }
12722 
12723 
12724 
12725  protected:
12726  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12727 
12728  public:
12732  {
12733  return m_pImpinjDirectionUserTagPopulationLimit;
12734  }
12735 
12737  EResultCode
12738  setImpinjDirectionUserTagPopulationLimit (
12740 
12741 
12742  protected:
12743  std::list<CParameter *> m_listCustom;
12744 
12745  public:
12747  inline std::list<CParameter *>::iterator
12749  {
12750  return m_listCustom.begin();
12751  }
12752 
12754  inline std::list<CParameter *>::iterator
12755  endCustom (void)
12756  {
12757  return m_listCustom.end();
12758  }
12759 
12761  inline void
12763  {
12764  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12765  }
12766 
12768  inline int
12770  {
12771  return (int) (m_listCustom.size());
12772  }
12773 
12774  EResultCode
12776  addCustom (
12777  CParameter * pValue);
12778 
12779 
12780 };
12781 
12782 
12805 class CImpinjDirectionUserTagPopulationLimit : public CParameter
12806 {
12807  public:
12810 
12813 
12814  static const CFieldDescriptor * const
12815  s_apFieldDescriptorTable[];
12816 
12817  static const CTypeDescriptor
12818  s_typeDescriptor;
12819 
12820  void
12821  decodeFields (
12822  CDecoderStream * pDecoderStream);
12823 
12824  void
12825  assimilateSubParameters (
12826  CErrorDetails * pError);
12827 
12828  void
12829  encode (
12830  CEncoderStream * pEncoderStream) const;
12831 
12832 
12833  llrp_bool_t
12834  isAllowedIn (
12835  const CTypeDescriptor * pEnclosingElementType) const;
12836 
12837 
12838  static CElement *
12839  s_construct (void);
12840 
12841  static void
12842  s_decodeFields (
12843  CDecoderStream * pDecoderStream,
12844  CElement * pElement);
12846 
12847 
12848  protected:
12849  llrp_u16_t m_UserTagPopulationLimit;
12850 
12853  public:
12854  static const CFieldDescriptor
12855  s_fdUserTagPopulationLimit;
12857 
12859  inline llrp_u16_t
12861  {
12862  return m_UserTagPopulationLimit;
12863  }
12864 
12866  inline void
12868  llrp_u16_t value)
12869  {
12870  m_UserTagPopulationLimit = value;
12871  }
12872 
12873 
12874 
12875 };
12876 
12877 
12915 class CImpinjC1G2DirectionConfig : public CParameter
12916 {
12917  public:
12920 
12923 
12924  static const CFieldDescriptor * const
12925  s_apFieldDescriptorTable[];
12926 
12927  static const CTypeDescriptor
12928  s_typeDescriptor;
12929 
12930  void
12931  decodeFields (
12932  CDecoderStream * pDecoderStream);
12933 
12934  void
12935  assimilateSubParameters (
12936  CErrorDetails * pError);
12937 
12938  void
12939  encode (
12940  CEncoderStream * pEncoderStream) const;
12941 
12942 
12943  llrp_bool_t
12944  isAllowedIn (
12945  const CTypeDescriptor * pEnclosingElementType) const;
12946 
12947 
12948  static CElement *
12949  s_construct (void);
12950 
12951  static void
12952  s_decodeFields (
12953  CDecoderStream * pDecoderStream,
12954  CElement * pElement);
12956 
12957 
12958  protected:
12959  EImpinjDirectionRFMode m_eRFMode;
12960 
12963  public:
12964  static const CFieldDescriptor
12965  s_fdRFMode;
12967 
12969  inline EImpinjDirectionRFMode
12970  getRFMode (void)
12971  {
12972  return m_eRFMode;
12973  }
12974 
12976  inline void
12978  EImpinjDirectionRFMode value)
12979  {
12980  m_eRFMode = value;
12981  }
12982 
12983 
12984 
12985  protected:
12986  CImpinjTransmitPower * m_pImpinjTransmitPower;
12987 
12988  public:
12990  inline CImpinjTransmitPower *
12992  {
12993  return m_pImpinjTransmitPower;
12994  }
12995 
12997  EResultCode
12998  setImpinjTransmitPower (
12999  CImpinjTransmitPower * pValue);
13000 
13001 
13002  protected:
13003  std::list<CC1G2Filter *> m_listC1G2Filter;
13004 
13005  public:
13007  inline std::list<CC1G2Filter *>::iterator
13009  {
13010  return m_listC1G2Filter.begin();
13011  }
13012 
13014  inline std::list<CC1G2Filter *>::iterator
13016  {
13017  return m_listC1G2Filter.end();
13018  }
13019 
13021  inline void
13023  {
13024  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
13025  }
13026 
13028  inline int
13030  {
13031  return (int) (m_listC1G2Filter.size());
13032  }
13033 
13034  EResultCode
13036  addC1G2Filter (
13037  CC1G2Filter * pValue);
13038 
13039 
13040  protected:
13041  std::list<CParameter *> m_listCustom;
13042 
13043  public:
13045  inline std::list<CParameter *>::iterator
13047  {
13048  return m_listCustom.begin();
13049  }
13050 
13052  inline std::list<CParameter *>::iterator
13053  endCustom (void)
13054  {
13055  return m_listCustom.end();
13056  }
13057 
13059  inline void
13061  {
13062  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13063  }
13064 
13066  inline int
13068  {
13069  return (int) (m_listCustom.size());
13070  }
13071 
13072  EResultCode
13074  addCustom (
13075  CParameter * pValue);
13076 
13077 
13078 };
13079 
13080 
13113 class CImpinjExtendedTagInformation : public CParameter
13114 {
13115  public:
13118 
13121 
13122  static const CFieldDescriptor * const
13123  s_apFieldDescriptorTable[];
13124 
13125  static const CTypeDescriptor
13126  s_typeDescriptor;
13127 
13128  void
13129  decodeFields (
13130  CDecoderStream * pDecoderStream);
13131 
13132  void
13133  assimilateSubParameters (
13134  CErrorDetails * pError);
13135 
13136  void
13137  encode (
13138  CEncoderStream * pEncoderStream) const;
13139 
13140 
13141  llrp_bool_t
13142  isAllowedIn (
13143  const CTypeDescriptor * pEnclosingElementType) const;
13144 
13145 
13146  static CElement *
13147  s_construct (void);
13148 
13149  static void
13150  s_decodeFields (
13151  CDecoderStream * pDecoderStream,
13152  CElement * pElement);
13154 
13155 
13156 
13157  protected:
13158  std::list<CEPCData *> m_listEPCData;
13159 
13160  public:
13162  inline std::list<CEPCData *>::iterator
13164  {
13165  return m_listEPCData.begin();
13166  }
13167 
13169  inline std::list<CEPCData *>::iterator
13170  endEPCData (void)
13171  {
13172  return m_listEPCData.end();
13173  }
13174 
13176  inline void
13178  {
13179  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
13180  }
13181 
13183  inline int
13185  {
13186  return (int) (m_listEPCData.size());
13187  }
13188 
13189  EResultCode
13191  addEPCData (
13192  CEPCData * pValue);
13193 
13194 
13195  protected:
13196  CImpinjLocationReportData * m_pImpinjLocationReportData;
13197 
13198  public:
13200  inline CImpinjLocationReportData *
13202  {
13203  return m_pImpinjLocationReportData;
13204  }
13205 
13207  EResultCode
13208  setImpinjLocationReportData (
13209  CImpinjLocationReportData * pValue);
13210 
13211 
13212  protected:
13213  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
13214 
13215  public:
13219  {
13220  return m_pImpinjDirectionReportData;
13221  }
13222 
13224  EResultCode
13225  setImpinjDirectionReportData (
13226  CImpinjDirectionReportData * pValue);
13227 
13228 
13229  protected:
13230  std::list<CParameter *> m_listCustom;
13231 
13232  public:
13234  inline std::list<CParameter *>::iterator
13236  {
13237  return m_listCustom.begin();
13238  }
13239 
13241  inline std::list<CParameter *>::iterator
13242  endCustom (void)
13243  {
13244  return m_listCustom.end();
13245  }
13246 
13248  inline void
13250  {
13251  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13252  }
13253 
13255  inline int
13257  {
13258  return (int) (m_listCustom.size());
13259  }
13260 
13261  EResultCode
13263  addCustom (
13264  CParameter * pValue);
13265 
13266 
13267 };
13268 
13269 
13316 class CImpinjDirectionReporting : public CParameter
13317 {
13318  public:
13320  ~CImpinjDirectionReporting (void);
13321 
13324 
13325  static const CFieldDescriptor * const
13326  s_apFieldDescriptorTable[];
13327 
13328  static const CTypeDescriptor
13329  s_typeDescriptor;
13330 
13331  void
13332  decodeFields (
13333  CDecoderStream * pDecoderStream);
13334 
13335  void
13336  assimilateSubParameters (
13337  CErrorDetails * pError);
13338 
13339  void
13340  encode (
13341  CEncoderStream * pEncoderStream) const;
13342 
13343 
13344  llrp_bool_t
13345  isAllowedIn (
13346  const CTypeDescriptor * pEnclosingElementType) const;
13347 
13348 
13349  static CElement *
13350  s_construct (void);
13351 
13352  static void
13353  s_decodeFields (
13354  CDecoderStream * pDecoderStream,
13355  CElement * pElement);
13357 
13358 
13359  protected:
13360  llrp_u1_t m_EnableUpdateReport;
13361 
13364  public:
13365  static const CFieldDescriptor
13366  s_fdEnableUpdateReport;
13368 
13370  inline llrp_u1_t
13372  {
13373  return m_EnableUpdateReport;
13374  }
13375 
13377  inline void
13379  llrp_u1_t value)
13380  {
13381  m_EnableUpdateReport = value;
13382  }
13383 
13384 
13385  protected:
13386  llrp_u1_t m_EnableEntryReport;
13387 
13390  public:
13391  static const CFieldDescriptor
13392  s_fdEnableEntryReport;
13394 
13396  inline llrp_u1_t
13398  {
13399  return m_EnableEntryReport;
13400  }
13401 
13403  inline void
13405  llrp_u1_t value)
13406  {
13407  m_EnableEntryReport = value;
13408  }
13409 
13410 
13411  protected:
13412  llrp_u1_t m_EnableExitReport;
13413 
13416  public:
13417  static const CFieldDescriptor
13418  s_fdEnableExitReport;
13420 
13422  inline llrp_u1_t
13424  {
13425  return m_EnableExitReport;
13426  }
13427 
13429  inline void
13431  llrp_u1_t value)
13432  {
13433  m_EnableExitReport = value;
13434  }
13435 
13436 
13437  protected:
13438  llrp_u1_t m_EnableDiagnosticReport;
13439 
13442  public:
13443  static const CFieldDescriptor
13444  s_fdEnableDiagnosticReport;
13446 
13448  inline llrp_u1_t
13450  {
13451  return m_EnableDiagnosticReport;
13452  }
13453 
13455  inline void
13457  llrp_u1_t value)
13458  {
13459  m_EnableDiagnosticReport = value;
13460  }
13461 
13462 
13463  protected:
13464  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
13465 
13468  public:
13469  static const CFieldDescriptor
13470  s_fdDiagnosticReportLevel;
13472 
13474  inline EImpinjDirectionDiagnosticReportLevel
13476  {
13477  return m_eDiagnosticReportLevel;
13478  }
13479 
13481  inline void
13483  EImpinjDirectionDiagnosticReportLevel value)
13484  {
13485  m_eDiagnosticReportLevel = value;
13486  }
13487 
13488 
13489 
13490  protected:
13491  std::list<CParameter *> m_listCustom;
13492 
13493  public:
13495  inline std::list<CParameter *>::iterator
13497  {
13498  return m_listCustom.begin();
13499  }
13500 
13502  inline std::list<CParameter *>::iterator
13503  endCustom (void)
13504  {
13505  return m_listCustom.end();
13506  }
13507 
13509  inline void
13511  {
13512  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13513  }
13514 
13516  inline int
13518  {
13519  return (int) (m_listCustom.size());
13520  }
13521 
13522  EResultCode
13524  addCustom (
13525  CParameter * pValue);
13526 
13527 
13528 };
13529 
13530 
13578 class CImpinjDirectionReportData : public CParameter
13579 {
13580  public:
13583 
13586 
13587  static const CFieldDescriptor * const
13588  s_apFieldDescriptorTable[];
13589 
13590  static const CTypeDescriptor
13591  s_typeDescriptor;
13592 
13593  void
13594  decodeFields (
13595  CDecoderStream * pDecoderStream);
13596 
13597  void
13598  assimilateSubParameters (
13599  CErrorDetails * pError);
13600 
13601  void
13602  encode (
13603  CEncoderStream * pEncoderStream) const;
13604 
13605 
13606  llrp_bool_t
13607  isAllowedIn (
13608  const CTypeDescriptor * pEnclosingElementType) const;
13609 
13610 
13611  static CElement *
13612  s_construct (void);
13613 
13614  static void
13615  s_decodeFields (
13616  CDecoderStream * pDecoderStream,
13617  CElement * pElement);
13619 
13620 
13621  protected:
13622  EImpinjDirectionReportType m_eType;
13623 
13626  public:
13627  static const CFieldDescriptor
13628  s_fdType;
13630 
13632  inline EImpinjDirectionReportType
13633  getType (void)
13634  {
13635  return m_eType;
13636  }
13637 
13639  inline void
13641  EImpinjDirectionReportType value)
13642  {
13643  m_eType = value;
13644  }
13645 
13646 
13647  protected:
13648  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13649 
13652  public:
13653  static const CFieldDescriptor
13654  s_fdTagPopulationStatus;
13656 
13658  inline EImpinjDirectionTagPopulationStatus
13660  {
13661  return m_eTagPopulationStatus;
13662  }
13663 
13665  inline void
13667  EImpinjDirectionTagPopulationStatus value)
13668  {
13669  m_eTagPopulationStatus = value;
13670  }
13671 
13672 
13673  protected:
13674  llrp_u8_t m_FirstSeenSectorID;
13675 
13678  public:
13679  static const CFieldDescriptor
13680  s_fdFirstSeenSectorID;
13682 
13684  inline llrp_u8_t
13686  {
13687  return m_FirstSeenSectorID;
13688  }
13689 
13691  inline void
13693  llrp_u8_t value)
13694  {
13695  m_FirstSeenSectorID = value;
13696  }
13697 
13698 
13699  protected:
13700  llrp_u64_t m_FirstSeenTimestampUTC;
13701 
13704  public:
13705  static const CFieldDescriptor
13706  s_fdFirstSeenTimestampUTC;
13708 
13710  inline llrp_u64_t
13712  {
13713  return m_FirstSeenTimestampUTC;
13714  }
13715 
13717  inline void
13719  llrp_u64_t value)
13720  {
13721  m_FirstSeenTimestampUTC = value;
13722  }
13723 
13724 
13725  protected:
13726  llrp_u8_t m_LastSeenSectorID;
13727 
13730  public:
13731  static const CFieldDescriptor
13732  s_fdLastSeenSectorID;
13734 
13736  inline llrp_u8_t
13738  {
13739  return m_LastSeenSectorID;
13740  }
13741 
13743  inline void
13745  llrp_u8_t value)
13746  {
13747  m_LastSeenSectorID = value;
13748  }
13749 
13750 
13751  protected:
13752  llrp_u64_t m_LastSeenTimestampUTC;
13753 
13756  public:
13757  static const CFieldDescriptor
13758  s_fdLastSeenTimestampUTC;
13760 
13762  inline llrp_u64_t
13764  {
13765  return m_LastSeenTimestampUTC;
13766  }
13767 
13769  inline void
13771  llrp_u64_t value)
13772  {
13773  m_LastSeenTimestampUTC = value;
13774  }
13775 
13776 
13777 
13778  protected:
13779  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13780 
13781  public:
13785  {
13786  return m_pImpinjDirectionDiagnosticData;
13787  }
13788 
13790  EResultCode
13791  setImpinjDirectionDiagnosticData (
13793 
13794 
13795  protected:
13796  std::list<CParameter *> m_listCustom;
13797 
13798  public:
13800  inline std::list<CParameter *>::iterator
13802  {
13803  return m_listCustom.begin();
13804  }
13805 
13807  inline std::list<CParameter *>::iterator
13808  endCustom (void)
13809  {
13810  return m_listCustom.end();
13811  }
13812 
13814  inline void
13816  {
13817  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13818  }
13819 
13821  inline int
13823  {
13824  return (int) (m_listCustom.size());
13825  }
13826 
13827  EResultCode
13829  addCustom (
13830  CParameter * pValue);
13831 
13832 
13833 };
13834 
13835 
13858 class CImpinjDirectionDiagnosticData : public CParameter
13859 {
13860  public:
13863 
13866 
13867  static const CFieldDescriptor * const
13868  s_apFieldDescriptorTable[];
13869 
13870  static const CTypeDescriptor
13871  s_typeDescriptor;
13872 
13873  void
13874  decodeFields (
13875  CDecoderStream * pDecoderStream);
13876 
13877  void
13878  assimilateSubParameters (
13879  CErrorDetails * pError);
13880 
13881  void
13882  encode (
13883  CEncoderStream * pEncoderStream) const;
13884 
13885 
13886  llrp_bool_t
13887  isAllowedIn (
13888  const CTypeDescriptor * pEnclosingElementType) const;
13889 
13890 
13891  static CElement *
13892  s_construct (void);
13893 
13894  static void
13895  s_decodeFields (
13896  CDecoderStream * pDecoderStream,
13897  CElement * pElement);
13899 
13900 
13901  protected:
13902  llrp_u32v_t m_Metric;
13903 
13906  public:
13907  static const CFieldDescriptor
13908  s_fdMetric;
13910 
13912  inline llrp_u32v_t
13913  getMetric (void)
13914  {
13915  return m_Metric;
13916  }
13917 
13919  inline void
13921  llrp_u32v_t value)
13922  {
13923  m_Metric = value;
13924  }
13925 
13926 
13927 
13928 };
13929 
13930 
13955 class CImpinjxArrayDirectionCapabilities : public CParameter
13956 {
13957  public:
13960 
13963 
13964  static const CFieldDescriptor * const
13965  s_apFieldDescriptorTable[];
13966 
13967  static const CTypeDescriptor
13968  s_typeDescriptor;
13969 
13970  void
13971  decodeFields (
13972  CDecoderStream * pDecoderStream);
13973 
13974  void
13975  assimilateSubParameters (
13976  CErrorDetails * pError);
13977 
13978  void
13979  encode (
13980  CEncoderStream * pEncoderStream) const;
13981 
13982 
13983  llrp_bool_t
13984  isAllowedIn (
13985  const CTypeDescriptor * pEnclosingElementType) const;
13986 
13987 
13988  static CElement *
13989  s_construct (void);
13990 
13991  static void
13992  s_decodeFields (
13993  CDecoderStream * pDecoderStream,
13994  CElement * pElement);
13996 
13997 
13998  protected:
13999  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
14000 
14003  public:
14004  static const CFieldDescriptor
14005  s_fdSystemTagPopulationLimitHighSensitivity;
14007 
14009  inline llrp_u16_t
14011  {
14012  return m_SystemTagPopulationLimitHighSensitivity;
14013  }
14014 
14016  inline void
14018  llrp_u16_t value)
14019  {
14020  m_SystemTagPopulationLimitHighSensitivity = value;
14021  }
14022 
14023 
14024  protected:
14025  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
14026 
14029  public:
14030  static const CFieldDescriptor
14031  s_fdSystemTagPopulationLimitHighPerformance;
14033 
14035  inline llrp_u16_t
14037  {
14038  return m_SystemTagPopulationLimitHighPerformance;
14039  }
14040 
14042  inline void
14044  llrp_u16_t value)
14045  {
14046  m_SystemTagPopulationLimitHighPerformance = value;
14047  }
14048 
14049 
14050 
14051  protected:
14052  std::list<CParameter *> m_listCustom;
14053 
14054  public:
14056  inline std::list<CParameter *>::iterator
14058  {
14059  return m_listCustom.begin();
14060  }
14061 
14063  inline std::list<CParameter *>::iterator
14064  endCustom (void)
14065  {
14066  return m_listCustom.end();
14067  }
14068 
14070  inline void
14072  {
14073  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14074  }
14075 
14077  inline int
14079  {
14080  return (int) (m_listCustom.size());
14081  }
14082 
14083  EResultCode
14085  addCustom (
14086  CParameter * pValue);
14087 
14088 
14089 };
14090 
14091 
14117 class CImpinjIntelligentAntennaManagement : public CParameter
14118 {
14119  public:
14122 
14125 
14126  static const CFieldDescriptor * const
14127  s_apFieldDescriptorTable[];
14128 
14129  static const CTypeDescriptor
14130  s_typeDescriptor;
14131 
14132  void
14133  decodeFields (
14134  CDecoderStream * pDecoderStream);
14135 
14136  void
14137  assimilateSubParameters (
14138  CErrorDetails * pError);
14139 
14140  void
14141  encode (
14142  CEncoderStream * pEncoderStream) const;
14143 
14144 
14145  llrp_bool_t
14146  isAllowedIn (
14147  const CTypeDescriptor * pEnclosingElementType) const;
14148 
14149 
14150  static CElement *
14151  s_construct (void);
14152 
14153  static void
14154  s_decodeFields (
14155  CDecoderStream * pDecoderStream,
14156  CElement * pElement);
14158 
14159 
14160  protected:
14161  EImpinjIntelligentAntennaMode m_eManagementEnabled;
14162 
14165  public:
14166  static const CFieldDescriptor
14167  s_fdManagementEnabled;
14169 
14171  inline EImpinjIntelligentAntennaMode
14173  {
14174  return m_eManagementEnabled;
14175  }
14176 
14178  inline void
14180  EImpinjIntelligentAntennaMode value)
14181  {
14182  m_eManagementEnabled = value;
14183  }
14184 
14185 
14186 
14187  protected:
14188  std::list<CParameter *> m_listCustom;
14189 
14190  public:
14192  inline std::list<CParameter *>::iterator
14194  {
14195  return m_listCustom.begin();
14196  }
14197 
14199  inline std::list<CParameter *>::iterator
14200  endCustom (void)
14201  {
14202  return m_listCustom.end();
14203  }
14204 
14206  inline void
14208  {
14209  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14210  }
14211 
14213  inline int
14215  {
14216  return (int) (m_listCustom.size());
14217  }
14218 
14219  EResultCode
14221  addCustom (
14222  CParameter * pValue);
14223 
14224 
14225 };
14226 
14227 
14254 class CImpinjTransmitPower : public CParameter
14255 {
14256  public:
14257  CImpinjTransmitPower (void);
14258  ~CImpinjTransmitPower (void);
14259 
14262 
14263  static const CFieldDescriptor * const
14264  s_apFieldDescriptorTable[];
14265 
14266  static const CTypeDescriptor
14267  s_typeDescriptor;
14268 
14269  void
14270  decodeFields (
14271  CDecoderStream * pDecoderStream);
14272 
14273  void
14274  assimilateSubParameters (
14275  CErrorDetails * pError);
14276 
14277  void
14278  encode (
14279  CEncoderStream * pEncoderStream) const;
14280 
14281 
14282  llrp_bool_t
14283  isAllowedIn (
14284  const CTypeDescriptor * pEnclosingElementType) const;
14285 
14286 
14287  static CElement *
14288  s_construct (void);
14289 
14290  static void
14291  s_decodeFields (
14292  CDecoderStream * pDecoderStream,
14293  CElement * pElement);
14295 
14296 
14297  protected:
14298  llrp_u16_t m_TransmitPower;
14299 
14302  public:
14303  static const CFieldDescriptor
14304  s_fdTransmitPower;
14306 
14308  inline llrp_u16_t
14310  {
14311  return m_TransmitPower;
14312  }
14313 
14315  inline void
14317  llrp_u16_t value)
14318  {
14319  m_TransmitPower = value;
14320  }
14321 
14322 
14323 
14324  protected:
14325  std::list<CParameter *> m_listCustom;
14326 
14327  public:
14329  inline std::list<CParameter *>::iterator
14331  {
14332  return m_listCustom.begin();
14333  }
14334 
14336  inline std::list<CParameter *>::iterator
14337  endCustom (void)
14338  {
14339  return m_listCustom.end();
14340  }
14341 
14343  inline void
14345  {
14346  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14347  }
14348 
14350  inline int
14352  {
14353  return (int) (m_listCustom.size());
14354  }
14355 
14356  EResultCode
14358  addCustom (
14359  CParameter * pValue);
14360 
14361 
14362 };
14363 
14364 
14391 class CImpinjPolarizationControl : public CParameter
14392 {
14393  public:
14396 
14399 
14400  static const CFieldDescriptor * const
14401  s_apFieldDescriptorTable[];
14402 
14403  static const CTypeDescriptor
14404  s_typeDescriptor;
14405 
14406  void
14407  decodeFields (
14408  CDecoderStream * pDecoderStream);
14409 
14410  void
14411  assimilateSubParameters (
14412  CErrorDetails * pError);
14413 
14414  void
14415  encode (
14416  CEncoderStream * pEncoderStream) const;
14417 
14418 
14419  llrp_bool_t
14420  isAllowedIn (
14421  const CTypeDescriptor * pEnclosingElementType) const;
14422 
14423 
14424  static CElement *
14425  s_construct (void);
14426 
14427  static void
14428  s_decodeFields (
14429  CDecoderStream * pDecoderStream,
14430  CElement * pElement);
14432 
14433 
14434  protected:
14435  llrp_u1_t m_PolarizationControlEnabled;
14436 
14439  public:
14440  static const CFieldDescriptor
14441  s_fdPolarizationControlEnabled;
14443 
14445  inline llrp_u1_t
14447  {
14448  return m_PolarizationControlEnabled;
14449  }
14450 
14452  inline void
14454  llrp_u1_t value)
14455  {
14456  m_PolarizationControlEnabled = value;
14457  }
14458 
14459 
14460 
14461  protected:
14462  std::list<CParameter *> m_listCustom;
14463 
14464  public:
14466  inline std::list<CParameter *>::iterator
14468  {
14469  return m_listCustom.begin();
14470  }
14471 
14473  inline std::list<CParameter *>::iterator
14474  endCustom (void)
14475  {
14476  return m_listCustom.end();
14477  }
14478 
14480  inline void
14482  {
14483  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14484  }
14485 
14487  inline int
14489  {
14490  return (int) (m_listCustom.size());
14491  }
14492 
14493  EResultCode
14495  addCustom (
14496  CParameter * pValue);
14497 
14498 
14499 };
14500 
14501 
14526 class CImpinjAntennaCapabilities : public CParameter
14527 {
14528  public:
14531 
14534 
14535  static const CFieldDescriptor * const
14536  s_apFieldDescriptorTable[];
14537 
14538  static const CTypeDescriptor
14539  s_typeDescriptor;
14540 
14541  void
14542  decodeFields (
14543  CDecoderStream * pDecoderStream);
14544 
14545  void
14546  assimilateSubParameters (
14547  CErrorDetails * pError);
14548 
14549  void
14550  encode (
14551  CEncoderStream * pEncoderStream) const;
14552 
14553 
14554  llrp_bool_t
14555  isAllowedIn (
14556  const CTypeDescriptor * pEnclosingElementType) const;
14557 
14558 
14559  static CElement *
14560  s_construct (void);
14561 
14562  static void
14563  s_decodeFields (
14564  CDecoderStream * pDecoderStream,
14565  CElement * pElement);
14567 
14568 
14569 
14570  protected:
14571  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
14572 
14573  public:
14575  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14577  {
14578  return m_listImpinjAntennaPolarizationCapability.begin();
14579  }
14580 
14582  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14584  {
14585  return m_listImpinjAntennaPolarizationCapability.end();
14586  }
14587 
14589  inline void
14591  {
14592  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
14593  }
14594 
14596  inline int
14598  {
14599  return (int) (m_listImpinjAntennaPolarizationCapability.size());
14600  }
14601 
14602  EResultCode
14604  addImpinjAntennaPolarizationCapability (
14606 
14607 
14608  protected:
14609  std::list<CParameter *> m_listCustom;
14610 
14611  public:
14613  inline std::list<CParameter *>::iterator
14615  {
14616  return m_listCustom.begin();
14617  }
14618 
14620  inline std::list<CParameter *>::iterator
14621  endCustom (void)
14622  {
14623  return m_listCustom.end();
14624  }
14625 
14627  inline void
14629  {
14630  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14631  }
14632 
14634  inline int
14636  {
14637  return (int) (m_listCustom.size());
14638  }
14639 
14640  EResultCode
14642  addCustom (
14643  CParameter * pValue);
14644 
14645 
14646 };
14647 
14648 
14673 class CImpinjAntennaPolarizationCapability : public CParameter
14674 {
14675  public:
14678 
14681 
14682  static const CFieldDescriptor * const
14683  s_apFieldDescriptorTable[];
14684 
14685  static const CTypeDescriptor
14686  s_typeDescriptor;
14687 
14688  void
14689  decodeFields (
14690  CDecoderStream * pDecoderStream);
14691 
14692  void
14693  assimilateSubParameters (
14694  CErrorDetails * pError);
14695 
14696  void
14697  encode (
14698  CEncoderStream * pEncoderStream) const;
14699 
14700 
14701  llrp_bool_t
14702  isAllowedIn (
14703  const CTypeDescriptor * pEnclosingElementType) const;
14704 
14705 
14706  static CElement *
14707  s_construct (void);
14708 
14709  static void
14710  s_decodeFields (
14711  CDecoderStream * pDecoderStream,
14712  CElement * pElement);
14714 
14715 
14716  protected:
14717  EImpinjAntennaPolarizationType m_eType;
14718 
14721  public:
14722  static const CFieldDescriptor
14723  s_fdType;
14725 
14727  inline EImpinjAntennaPolarizationType
14728  getType (void)
14729  {
14730  return m_eType;
14731  }
14732 
14734  inline void
14736  EImpinjAntennaPolarizationType value)
14737  {
14738  m_eType = value;
14739  }
14740 
14741 
14742  protected:
14743  llrp_u16_t m_AntennaIDOffset;
14744 
14747  public:
14748  static const CFieldDescriptor
14749  s_fdAntennaIDOffset;
14751 
14753  inline llrp_u16_t
14755  {
14756  return m_AntennaIDOffset;
14757  }
14758 
14760  inline void
14762  llrp_u16_t value)
14763  {
14764  m_AntennaIDOffset = value;
14765  }
14766 
14767 
14768 
14769  protected:
14770  std::list<CParameter *> m_listCustom;
14771 
14772  public:
14774  inline std::list<CParameter *>::iterator
14776  {
14777  return m_listCustom.begin();
14778  }
14779 
14781  inline std::list<CParameter *>::iterator
14782  endCustom (void)
14783  {
14784  return m_listCustom.end();
14785  }
14786 
14788  inline void
14790  {
14791  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14792  }
14793 
14795  inline int
14797  {
14798  return (int) (m_listCustom.size());
14799  }
14800 
14801  EResultCode
14803  addCustom (
14804  CParameter * pValue);
14805 
14806 
14807 };
14808 
14809 
14833 class CImpinjDisabledAntennas : public CParameter
14834 {
14835  public:
14836  CImpinjDisabledAntennas (void);
14837  ~CImpinjDisabledAntennas (void);
14838 
14841 
14842  static const CFieldDescriptor * const
14843  s_apFieldDescriptorTable[];
14844 
14845  static const CTypeDescriptor
14846  s_typeDescriptor;
14847 
14848  void
14849  decodeFields (
14850  CDecoderStream * pDecoderStream);
14851 
14852  void
14853  assimilateSubParameters (
14854  CErrorDetails * pError);
14855 
14856  void
14857  encode (
14858  CEncoderStream * pEncoderStream) const;
14859 
14860 
14861  llrp_bool_t
14862  isAllowedIn (
14863  const CTypeDescriptor * pEnclosingElementType) const;
14864 
14865 
14866  static CElement *
14867  s_construct (void);
14868 
14869  static void
14870  s_decodeFields (
14871  CDecoderStream * pDecoderStream,
14872  CElement * pElement);
14874 
14875 
14876  protected:
14877  llrp_u16v_t m_AntennaIDs;
14878 
14881  public:
14882  static const CFieldDescriptor
14883  s_fdAntennaIDs;
14885 
14887  inline llrp_u16v_t
14889  {
14890  return m_AntennaIDs;
14891  }
14892 
14894  inline void
14896  llrp_u16v_t value)
14897  {
14898  m_AntennaIDs = value;
14899  }
14900 
14901 
14902 
14903  protected:
14904  std::list<CParameter *> m_listCustom;
14905 
14906  public:
14908  inline std::list<CParameter *>::iterator
14910  {
14911  return m_listCustom.begin();
14912  }
14913 
14915  inline std::list<CParameter *>::iterator
14916  endCustom (void)
14917  {
14918  return m_listCustom.end();
14919  }
14920 
14922  inline void
14924  {
14925  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14926  }
14927 
14929  inline int
14931  {
14932  return (int) (m_listCustom.size());
14933  }
14934 
14935  EResultCode
14937  addCustom (
14938  CParameter * pValue);
14939 
14940 
14941 };
14942 
14943 
14968 class CImpinjTIDParity : public CParameter
14969 {
14970  public:
14971  CImpinjTIDParity (void);
14972  ~CImpinjTIDParity (void);
14973 
14976 
14977  static const CFieldDescriptor * const
14978  s_apFieldDescriptorTable[];
14979 
14980  static const CTypeDescriptor
14981  s_typeDescriptor;
14982 
14983  void
14984  decodeFields (
14985  CDecoderStream * pDecoderStream);
14986 
14987  void
14988  assimilateSubParameters (
14989  CErrorDetails * pError);
14990 
14991  void
14992  encode (
14993  CEncoderStream * pEncoderStream) const;
14994 
14995 
14996  llrp_bool_t
14997  isAllowedIn (
14998  const CTypeDescriptor * pEnclosingElementType) const;
14999 
15000 
15001  static CElement *
15002  s_construct (void);
15003 
15004  static void
15005  s_decodeFields (
15006  CDecoderStream * pDecoderStream,
15007  CElement * pElement);
15009 
15010 
15011  protected:
15012  llrp_u1_t m_ParityError;
15013 
15016  public:
15017  static const CFieldDescriptor
15018  s_fdParityError;
15020 
15022  inline llrp_u1_t
15024  {
15025  return m_ParityError;
15026  }
15027 
15029  inline void
15031  llrp_u1_t value)
15032  {
15033  m_ParityError = value;
15034  }
15035 
15036 
15037 
15038  protected:
15039  std::list<CParameter *> m_listCustom;
15040 
15041  public:
15043  inline std::list<CParameter *>::iterator
15045  {
15046  return m_listCustom.begin();
15047  }
15048 
15050  inline std::list<CParameter *>::iterator
15051  endCustom (void)
15052  {
15053  return m_listCustom.end();
15054  }
15055 
15057  inline void
15059  {
15060  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15061  }
15062 
15064  inline int
15066  {
15067  return (int) (m_listCustom.size());
15068  }
15069 
15070  EResultCode
15072  addCustom (
15073  CParameter * pValue);
15074 
15075 
15076 };
15077 
15078 
15109 class CImpinjMarginRead : public CParameter
15110 {
15111  public:
15112  CImpinjMarginRead (void);
15113  ~CImpinjMarginRead (void);
15114 
15117 
15118  static const CFieldDescriptor * const
15119  s_apFieldDescriptorTable[];
15120 
15121  static const CTypeDescriptor
15122  s_typeDescriptor;
15123 
15124  void
15125  decodeFields (
15126  CDecoderStream * pDecoderStream);
15127 
15128  void
15129  assimilateSubParameters (
15130  CErrorDetails * pError);
15131 
15132  void
15133  encode (
15134  CEncoderStream * pEncoderStream) const;
15135 
15136 
15137  llrp_bool_t
15138  isAllowedIn (
15139  const CTypeDescriptor * pEnclosingElementType) const;
15140 
15141 
15142  static CElement *
15143  s_construct (void);
15144 
15145  static void
15146  s_decodeFields (
15147  CDecoderStream * pDecoderStream,
15148  CElement * pElement);
15150 
15151 
15152  protected:
15153  llrp_u16_t m_OpSpecID;
15154 
15157  public:
15158  static const CFieldDescriptor
15159  s_fdOpSpecID;
15161 
15163  inline llrp_u16_t
15165  {
15166  return m_OpSpecID;
15167  }
15168 
15170  inline void
15172  llrp_u16_t value)
15173  {
15174  m_OpSpecID = value;
15175  }
15176 
15177 
15178  protected:
15179  llrp_u32_t m_AccessPassword;
15180 
15183  public:
15184  static const CFieldDescriptor
15185  s_fdAccessPassword;
15187 
15189  inline llrp_u32_t
15191  {
15192  return m_AccessPassword;
15193  }
15194 
15196  inline void
15198  llrp_u32_t value)
15199  {
15200  m_AccessPassword = value;
15201  }
15202 
15203 
15204  protected:
15205  llrp_u2_t m_MB;
15206 
15209  public:
15210  static const CFieldDescriptor
15211  s_fdMB;
15213 
15215  inline llrp_u2_t
15216  getMB (void)
15217  {
15218  return m_MB;
15219  }
15220 
15222  inline void
15224  llrp_u2_t value)
15225  {
15226  m_MB = value;
15227  }
15228 
15229 
15230  protected:
15231  llrp_u16_t m_BitPointer;
15232 
15235  public:
15236  static const CFieldDescriptor
15237  s_fdBitPointer;
15239 
15241  inline llrp_u16_t
15243  {
15244  return m_BitPointer;
15245  }
15246 
15248  inline void
15250  llrp_u16_t value)
15251  {
15252  m_BitPointer = value;
15253  }
15254 
15255 
15256  protected:
15257  llrp_u8_t m_BitLength;
15258 
15261  public:
15262  static const CFieldDescriptor
15263  s_fdBitLength;
15265 
15267  inline llrp_u8_t
15269  {
15270  return m_BitLength;
15271  }
15272 
15274  inline void
15276  llrp_u8_t value)
15277  {
15278  m_BitLength = value;
15279  }
15280 
15281 
15282  protected:
15283  llrp_u16v_t m_Mask;
15284 
15287  public:
15288  static const CFieldDescriptor
15289  s_fdMask;
15291 
15293  inline llrp_u16v_t
15294  getMask (void)
15295  {
15296  return m_Mask;
15297  }
15298 
15300  inline void
15302  llrp_u16v_t value)
15303  {
15304  m_Mask = value;
15305  }
15306 
15307 
15308 
15309  protected:
15310  std::list<CParameter *> m_listCustom;
15311 
15312  public:
15314  inline std::list<CParameter *>::iterator
15316  {
15317  return m_listCustom.begin();
15318  }
15319 
15321  inline std::list<CParameter *>::iterator
15322  endCustom (void)
15323  {
15324  return m_listCustom.end();
15325  }
15326 
15328  inline void
15330  {
15331  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15332  }
15333 
15335  inline int
15337  {
15338  return (int) (m_listCustom.size());
15339  }
15340 
15341  EResultCode
15343  addCustom (
15344  CParameter * pValue);
15345 
15346 
15347 };
15348 
15349 
15375 class CImpinjMarginReadOpSpecResult : public CParameter
15376 {
15377  public:
15380 
15383 
15384  static const CFieldDescriptor * const
15385  s_apFieldDescriptorTable[];
15386 
15387  static const CTypeDescriptor
15388  s_typeDescriptor;
15389 
15390  void
15391  decodeFields (
15392  CDecoderStream * pDecoderStream);
15393 
15394  void
15395  assimilateSubParameters (
15396  CErrorDetails * pError);
15397 
15398  void
15399  encode (
15400  CEncoderStream * pEncoderStream) const;
15401 
15402 
15403  llrp_bool_t
15404  isAllowedIn (
15405  const CTypeDescriptor * pEnclosingElementType) const;
15406 
15407 
15408  static CElement *
15409  s_construct (void);
15410 
15411  static void
15412  s_decodeFields (
15413  CDecoderStream * pDecoderStream,
15414  CElement * pElement);
15416 
15417 
15418  protected:
15419  EImpinjMarginReadResultType m_eResult;
15420 
15423  public:
15424  static const CFieldDescriptor
15425  s_fdResult;
15427 
15429  inline EImpinjMarginReadResultType
15430  getResult (void)
15431  {
15432  return m_eResult;
15433  }
15434 
15436  inline void
15438  EImpinjMarginReadResultType value)
15439  {
15440  m_eResult = value;
15441  }
15442 
15443 
15444  protected:
15445  llrp_u16_t m_OpSpecID;
15446 
15449  public:
15450  static const CFieldDescriptor
15451  s_fdOpSpecID;
15453 
15455  inline llrp_u16_t
15457  {
15458  return m_OpSpecID;
15459  }
15460 
15462  inline void
15464  llrp_u16_t value)
15465  {
15466  m_OpSpecID = value;
15467  }
15468 
15469 
15470 
15471  protected:
15472  std::list<CParameter *> m_listCustom;
15473 
15474  public:
15476  inline std::list<CParameter *>::iterator
15478  {
15479  return m_listCustom.begin();
15480  }
15481 
15483  inline std::list<CParameter *>::iterator
15484  endCustom (void)
15485  {
15486  return m_listCustom.end();
15487  }
15488 
15490  inline void
15492  {
15493  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15494  }
15495 
15497  inline int
15499  {
15500  return (int) (m_listCustom.size());
15501  }
15502 
15503  EResultCode
15505  addCustom (
15506  CParameter * pValue);
15507 
15508 
15509 };
15510 
15511 
15536 class CImpinjBLEVersion : public CParameter
15537 {
15538  public:
15539  CImpinjBLEVersion (void);
15540  ~CImpinjBLEVersion (void);
15541 
15544 
15545  static const CFieldDescriptor * const
15546  s_apFieldDescriptorTable[];
15547 
15548  static const CTypeDescriptor
15549  s_typeDescriptor;
15550 
15551  void
15552  decodeFields (
15553  CDecoderStream * pDecoderStream);
15554 
15555  void
15556  assimilateSubParameters (
15557  CErrorDetails * pError);
15558 
15559  void
15560  encode (
15561  CEncoderStream * pEncoderStream) const;
15562 
15563 
15564  llrp_bool_t
15565  isAllowedIn (
15566  const CTypeDescriptor * pEnclosingElementType) const;
15567 
15568 
15569  static CElement *
15570  s_construct (void);
15571 
15572  static void
15573  s_decodeFields (
15574  CDecoderStream * pDecoderStream,
15575  CElement * pElement);
15577 
15578 
15579  protected:
15580  llrp_utf8v_t m_FirmwareVersion;
15581 
15584  public:
15585  static const CFieldDescriptor
15586  s_fdFirmwareVersion;
15588 
15590  inline llrp_utf8v_t
15592  {
15593  return m_FirmwareVersion;
15594  }
15595 
15597  inline void
15599  llrp_utf8v_t value)
15600  {
15601  m_FirmwareVersion = value;
15602  }
15603 
15604 
15605 
15606  protected:
15607  std::list<CParameter *> m_listCustom;
15608 
15609  public:
15611  inline std::list<CParameter *>::iterator
15613  {
15614  return m_listCustom.begin();
15615  }
15616 
15618  inline std::list<CParameter *>::iterator
15619  endCustom (void)
15620  {
15621  return m_listCustom.end();
15622  }
15623 
15625  inline void
15627  {
15628  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15629  }
15630 
15632  inline int
15634  {
15635  return (int) (m_listCustom.size());
15636  }
15637 
15638  EResultCode
15640  addCustom (
15641  CParameter * pValue);
15642 
15643 
15644 };
15645 
15646 
15670 class CImpinjLocationAlgorithmControl : public CParameter
15671 {
15672  public:
15675 
15678 
15679  static const CFieldDescriptor * const
15680  s_apFieldDescriptorTable[];
15681 
15682  static const CTypeDescriptor
15683  s_typeDescriptor;
15684 
15685  void
15686  decodeFields (
15687  CDecoderStream * pDecoderStream);
15688 
15689  void
15690  assimilateSubParameters (
15691  CErrorDetails * pError);
15692 
15693  void
15694  encode (
15695  CEncoderStream * pEncoderStream) const;
15696 
15697 
15698  llrp_bool_t
15699  isAllowedIn (
15700  const CTypeDescriptor * pEnclosingElementType) const;
15701 
15702 
15703  static CElement *
15704  s_construct (void);
15705 
15706  static void
15707  s_decodeFields (
15708  CDecoderStream * pDecoderStream,
15709  CElement * pElement);
15711 
15712 
15713  protected:
15714  llrp_u32v_t m_ControlData;
15715 
15718  public:
15719  static const CFieldDescriptor
15720  s_fdControlData;
15722 
15724  inline llrp_u32v_t
15726  {
15727  return m_ControlData;
15728  }
15729 
15731  inline void
15733  llrp_u32v_t value)
15734  {
15735  m_ControlData = value;
15736  }
15737 
15738 
15739 
15740  protected:
15741  std::list<CParameter *> m_listCustom;
15742 
15743  public:
15745  inline std::list<CParameter *>::iterator
15747  {
15748  return m_listCustom.begin();
15749  }
15750 
15752  inline std::list<CParameter *>::iterator
15753  endCustom (void)
15754  {
15755  return m_listCustom.end();
15756  }
15757 
15759  inline void
15761  {
15762  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15763  }
15764 
15766  inline int
15768  {
15769  return (int) (m_listCustom.size());
15770  }
15771 
15772  EResultCode
15774  addCustom (
15775  CParameter * pValue);
15776 
15777 
15778 };
15779 
15780 
15817 class CImpinjRFPowerSweep : public CParameter
15818 {
15819  public:
15820  CImpinjRFPowerSweep (void);
15821  ~CImpinjRFPowerSweep (void);
15822 
15825 
15826  static const CFieldDescriptor * const
15827  s_apFieldDescriptorTable[];
15828 
15829  static const CTypeDescriptor
15830  s_typeDescriptor;
15831 
15832  void
15833  decodeFields (
15834  CDecoderStream * pDecoderStream);
15835 
15836  void
15837  assimilateSubParameters (
15838  CErrorDetails * pError);
15839 
15840  void
15841  encode (
15842  CEncoderStream * pEncoderStream) const;
15843 
15844 
15845  llrp_bool_t
15846  isAllowedIn (
15847  const CTypeDescriptor * pEnclosingElementType) const;
15848 
15849 
15850  static CElement *
15851  s_construct (void);
15852 
15853  static void
15854  s_decodeFields (
15855  CDecoderStream * pDecoderStream,
15856  CElement * pElement);
15858 
15859 
15860  protected:
15861  llrp_u1_t m_EnableRFPowerSweep;
15862 
15865  public:
15866  static const CFieldDescriptor
15867  s_fdEnableRFPowerSweep;
15869 
15871  inline llrp_u1_t
15873  {
15874  return m_EnableRFPowerSweep;
15875  }
15876 
15878  inline void
15880  llrp_u1_t value)
15881  {
15882  m_EnableRFPowerSweep = value;
15883  }
15884 
15885 
15886  protected:
15887  llrp_u16_t m_MinimumPowerLevel;
15888 
15891  public:
15892  static const CFieldDescriptor
15893  s_fdMinimumPowerLevel;
15895 
15897  inline llrp_u16_t
15899  {
15900  return m_MinimumPowerLevel;
15901  }
15902 
15904  inline void
15906  llrp_u16_t value)
15907  {
15908  m_MinimumPowerLevel = value;
15909  }
15910 
15911 
15912  protected:
15913  llrp_u16_t m_PowerLevelStepSize;
15914 
15917  public:
15918  static const CFieldDescriptor
15919  s_fdPowerLevelStepSize;
15921 
15923  inline llrp_u16_t
15925  {
15926  return m_PowerLevelStepSize;
15927  }
15928 
15930  inline void
15932  llrp_u16_t value)
15933  {
15934  m_PowerLevelStepSize = value;
15935  }
15936 
15937 
15938 
15939  protected:
15940  std::list<CParameter *> m_listCustom;
15941 
15942  public:
15944  inline std::list<CParameter *>::iterator
15946  {
15947  return m_listCustom.begin();
15948  }
15949 
15951  inline std::list<CParameter *>::iterator
15952  endCustom (void)
15953  {
15954  return m_listCustom.end();
15955  }
15956 
15958  inline void
15960  {
15961  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15962  }
15963 
15965  inline int
15967  {
15968  return (int) (m_listCustom.size());
15969  }
15970 
15971  EResultCode
15973  addCustom (
15974  CParameter * pValue);
15975 
15976 
15977 };
15978 
15979 
16020 class CImpinjTruncatedReplyConfiguration : public CParameter
16021 {
16022  public:
16025 
16028 
16029  static const CFieldDescriptor * const
16030  s_apFieldDescriptorTable[];
16031 
16032  static const CTypeDescriptor
16033  s_typeDescriptor;
16034 
16035  void
16036  decodeFields (
16037  CDecoderStream * pDecoderStream);
16038 
16039  void
16040  assimilateSubParameters (
16041  CErrorDetails * pError);
16042 
16043  void
16044  encode (
16045  CEncoderStream * pEncoderStream) const;
16046 
16047 
16048  llrp_bool_t
16049  isAllowedIn (
16050  const CTypeDescriptor * pEnclosingElementType) const;
16051 
16052 
16053  static CElement *
16054  s_construct (void);
16055 
16056  static void
16057  s_decodeFields (
16058  CDecoderStream * pDecoderStream,
16059  CElement * pElement);
16061 
16062 
16063  protected:
16064  llrp_u1_t m_Gen2v2TagsOnly;
16065 
16068  public:
16069  static const CFieldDescriptor
16070  s_fdGen2v2TagsOnly;
16072 
16074  inline llrp_u1_t
16076  {
16077  return m_Gen2v2TagsOnly;
16078  }
16079 
16081  inline void
16083  llrp_u1_t value)
16084  {
16085  m_Gen2v2TagsOnly = value;
16086  }
16087 
16088 
16089  protected:
16090  llrp_u8_t m_EPCLength;
16091 
16094  public:
16095  static const CFieldDescriptor
16096  s_fdEPCLength;
16098 
16100  inline llrp_u8_t
16102  {
16103  return m_EPCLength;
16104  }
16105 
16107  inline void
16109  llrp_u8_t value)
16110  {
16111  m_EPCLength = value;
16112  }
16113 
16114 
16115  protected:
16116  llrp_u16_t m_Pointer;
16117 
16120  public:
16121  static const CFieldDescriptor
16122  s_fdPointer;
16124 
16126  inline llrp_u16_t
16127  getPointer (void)
16128  {
16129  return m_Pointer;
16130  }
16131 
16133  inline void
16135  llrp_u16_t value)
16136  {
16137  m_Pointer = value;
16138  }
16139 
16140 
16141  protected:
16142  llrp_u1v_t m_TagMask;
16143 
16146  public:
16147  static const CFieldDescriptor
16148  s_fdTagMask;
16150 
16152  inline llrp_u1v_t
16153  getTagMask (void)
16154  {
16155  return m_TagMask;
16156  }
16157 
16159  inline void
16161  llrp_u1v_t value)
16162  {
16163  m_TagMask = value;
16164  }
16165 
16166 
16167 
16168  protected:
16169  std::list<CParameter *> m_listCustom;
16170 
16171  public:
16173  inline std::list<CParameter *>::iterator
16175  {
16176  return m_listCustom.begin();
16177  }
16178 
16180  inline std::list<CParameter *>::iterator
16181  endCustom (void)
16182  {
16183  return m_listCustom.end();
16184  }
16185 
16187  inline void
16189  {
16190  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16191  }
16192 
16194  inline int
16196  {
16197  return (int) (m_listCustom.size());
16198  }
16199 
16200  EResultCode
16202  addCustom (
16203  CParameter * pValue);
16204 
16205 
16206 };
16207 
16208 
16254 class CImpinjAuthenticate : public CParameter
16255 {
16256  public:
16257  CImpinjAuthenticate (void);
16258  ~CImpinjAuthenticate (void);
16259 
16262 
16263  static const CFieldDescriptor * const
16264  s_apFieldDescriptorTable[];
16265 
16266  static const CTypeDescriptor
16267  s_typeDescriptor;
16268 
16269  void
16270  decodeFields (
16271  CDecoderStream * pDecoderStream);
16272 
16273  void
16274  assimilateSubParameters (
16275  CErrorDetails * pError);
16276 
16277  void
16278  encode (
16279  CEncoderStream * pEncoderStream) const;
16280 
16281 
16282  llrp_bool_t
16283  isAllowedIn (
16284  const CTypeDescriptor * pEnclosingElementType) const;
16285 
16286 
16287  static CElement *
16288  s_construct (void);
16289 
16290  static void
16291  s_decodeFields (
16292  CDecoderStream * pDecoderStream,
16293  CElement * pElement);
16295 
16296 
16297  protected:
16298  llrp_u16_t m_OpSpecID;
16299 
16302  public:
16303  static const CFieldDescriptor
16304  s_fdOpSpecID;
16306 
16308  inline llrp_u16_t
16310  {
16311  return m_OpSpecID;
16312  }
16313 
16315  inline void
16317  llrp_u16_t value)
16318  {
16319  m_OpSpecID = value;
16320  }
16321 
16322 
16323  protected:
16324  llrp_u32_t m_AccessPassword;
16325 
16328  public:
16329  static const CFieldDescriptor
16330  s_fdAccessPassword;
16332 
16334  inline llrp_u32_t
16336  {
16337  return m_AccessPassword;
16338  }
16339 
16341  inline void
16343  llrp_u32_t value)
16344  {
16345  m_AccessPassword = value;
16346  }
16347 
16348 
16349  protected:
16350  llrp_u1_t m_SendRep;
16351 
16354  public:
16355  static const CFieldDescriptor
16356  s_fdSendRep;
16358 
16360  inline llrp_u1_t
16361  getSendRep (void)
16362  {
16363  return m_SendRep;
16364  }
16365 
16367  inline void
16369  llrp_u1_t value)
16370  {
16371  m_SendRep = value;
16372  }
16373 
16374 
16375  protected:
16376  llrp_u1_t m_IncRepLen;
16377 
16380  public:
16381  static const CFieldDescriptor
16382  s_fdIncRepLen;
16384 
16386  inline llrp_u1_t
16388  {
16389  return m_IncRepLen;
16390  }
16391 
16393  inline void
16395  llrp_u1_t value)
16396  {
16397  m_IncRepLen = value;
16398  }
16399 
16400 
16401  protected:
16402  llrp_u8_t m_CSI;
16403 
16406  public:
16407  static const CFieldDescriptor
16408  s_fdCSI;
16410 
16412  inline llrp_u8_t
16413  getCSI (void)
16414  {
16415  return m_CSI;
16416  }
16417 
16419  inline void
16421  llrp_u8_t value)
16422  {
16423  m_CSI = value;
16424  }
16425 
16426 
16427  protected:
16428  llrp_u1v_t m_Message;
16429 
16432  public:
16433  static const CFieldDescriptor
16434  s_fdMessage;
16436 
16438  inline llrp_u1v_t
16439  getMessage (void)
16440  {
16441  return m_Message;
16442  }
16443 
16445  inline void
16447  llrp_u1v_t value)
16448  {
16449  m_Message = value;
16450  }
16451 
16452 
16453 
16454  protected:
16455  std::list<CParameter *> m_listCustom;
16456 
16457  public:
16459  inline std::list<CParameter *>::iterator
16461  {
16462  return m_listCustom.begin();
16463  }
16464 
16466  inline std::list<CParameter *>::iterator
16467  endCustom (void)
16468  {
16469  return m_listCustom.end();
16470  }
16471 
16473  inline void
16475  {
16476  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16477  }
16478 
16480  inline int
16482  {
16483  return (int) (m_listCustom.size());
16484  }
16485 
16486  EResultCode
16488  addCustom (
16489  CParameter * pValue);
16490 
16491 
16492 };
16493 
16494 
16524 class CImpinjAuthenticateOpSpecResult : public CParameter
16525 {
16526  public:
16529 
16532 
16533  static const CFieldDescriptor * const
16534  s_apFieldDescriptorTable[];
16535 
16536  static const CTypeDescriptor
16537  s_typeDescriptor;
16538 
16539  void
16540  decodeFields (
16541  CDecoderStream * pDecoderStream);
16542 
16543  void
16544  assimilateSubParameters (
16545  CErrorDetails * pError);
16546 
16547  void
16548  encode (
16549  CEncoderStream * pEncoderStream) const;
16550 
16551 
16552  llrp_bool_t
16553  isAllowedIn (
16554  const CTypeDescriptor * pEnclosingElementType) const;
16555 
16556 
16557  static CElement *
16558  s_construct (void);
16559 
16560  static void
16561  s_decodeFields (
16562  CDecoderStream * pDecoderStream,
16563  CElement * pElement);
16565 
16566 
16567  protected:
16568  EImpinjAuthenticateResultType m_eResult;
16569 
16572  public:
16573  static const CFieldDescriptor
16574  s_fdResult;
16576 
16578  inline EImpinjAuthenticateResultType
16579  getResult (void)
16580  {
16581  return m_eResult;
16582  }
16583 
16585  inline void
16587  EImpinjAuthenticateResultType value)
16588  {
16589  m_eResult = value;
16590  }
16591 
16592 
16593  protected:
16594  llrp_u16_t m_OpSpecID;
16595 
16598  public:
16599  static const CFieldDescriptor
16600  s_fdOpSpecID;
16602 
16604  inline llrp_u16_t
16606  {
16607  return m_OpSpecID;
16608  }
16609 
16611  inline void
16613  llrp_u16_t value)
16614  {
16615  m_OpSpecID = value;
16616  }
16617 
16618 
16619  protected:
16620  llrp_u1v_t m_Response;
16621 
16624  public:
16625  static const CFieldDescriptor
16626  s_fdResponse;
16628 
16630  inline llrp_u1v_t
16632  {
16633  return m_Response;
16634  }
16635 
16637  inline void
16639  llrp_u1v_t value)
16640  {
16641  m_Response = value;
16642  }
16643 
16644 
16645 
16646  protected:
16647  std::list<CParameter *> m_listCustom;
16648 
16649  public:
16651  inline std::list<CParameter *>::iterator
16653  {
16654  return m_listCustom.begin();
16655  }
16656 
16658  inline std::list<CParameter *>::iterator
16659  endCustom (void)
16660  {
16661  return m_listCustom.end();
16662  }
16663 
16665  inline void
16667  {
16668  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16669  }
16670 
16672  inline int
16674  {
16675  return (int) (m_listCustom.size());
16676  }
16677 
16678  EResultCode
16680  addCustom (
16681  CParameter * pValue);
16682 
16683 
16684 };
16685 
16686 
16714 class CImpinjTagFilterVerificationConfiguration : public CParameter
16715 {
16716  public:
16719 
16722 
16723  static const CFieldDescriptor * const
16724  s_apFieldDescriptorTable[];
16725 
16726  static const CTypeDescriptor
16727  s_typeDescriptor;
16728 
16729  void
16730  decodeFields (
16731  CDecoderStream * pDecoderStream);
16732 
16733  void
16734  assimilateSubParameters (
16735  CErrorDetails * pError);
16736 
16737  void
16738  encode (
16739  CEncoderStream * pEncoderStream) const;
16740 
16741 
16742  llrp_bool_t
16743  isAllowedIn (
16744  const CTypeDescriptor * pEnclosingElementType) const;
16745 
16746 
16747  static CElement *
16748  s_construct (void);
16749 
16750  static void
16751  s_decodeFields (
16752  CDecoderStream * pDecoderStream,
16753  CElement * pElement);
16755 
16756 
16757  protected:
16758  EImpinjTagFilterVerificationMode m_eTagFilterVerificationMode;
16759 
16762  public:
16763  static const CFieldDescriptor
16764  s_fdTagFilterVerificationMode;
16766 
16768  inline EImpinjTagFilterVerificationMode
16770  {
16771  return m_eTagFilterVerificationMode;
16772  }
16773 
16775  inline void
16777  EImpinjTagFilterVerificationMode value)
16778  {
16779  m_eTagFilterVerificationMode = value;
16780  }
16781 
16782 
16783 
16784  protected:
16785  std::list<CParameter *> m_listCustom;
16786 
16787  public:
16789  inline std::list<CParameter *>::iterator
16791  {
16792  return m_listCustom.begin();
16793  }
16794 
16796  inline std::list<CParameter *>::iterator
16797  endCustom (void)
16798  {
16799  return m_listCustom.end();
16800  }
16801 
16803  inline void
16805  {
16806  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16807  }
16808 
16810  inline int
16812  {
16813  return (int) (m_listCustom.size());
16814  }
16815 
16816  EResultCode
16818  addCustom (
16819  CParameter * pValue);
16820 
16821 
16822 };
16823 
16824 
16839 extern void
16841  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...
Class Definition CImpinjTagFilterVerificationConfiguration for LLRP parameter ImpinjTagFilterVerifica...
CImpinjHubVersions * getImpinjHubVersions(void)
Get accessor functions for the LLRP ImpinjHubVersions sub-parameter.
llrp_utf8v_t getRMCSentence(void)
Get accessor functions for the LLRP RMCSentence field.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16_t getRetryCount(void)
Get accessor functions for the LLRP RetryCount field.
llrp_u1_t getParityError(void)
Get accessor functions for the LLRP ParityError field.
CImpinjArrayVersion * getImpinjArrayVersion(void)
Get accessor functions for the LLRP ImpinjArrayVersion sub-parameter.
Class Definition CImpinjGetQTConfigOpSpecResult for LLRP parameter ImpinjGetQTConfigOpSpecResult.
void setTxPower(llrp_u16_t value)
Set accessor functions for the LLRP TxPower field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setFieldOfView(EImpinjDirectionFieldOfView value)
Set accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getBeaconState(void)
Get accessor functions for the LLRP BeaconState field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s32_t getFacilityYLocationCm(void)
Get accessor functions for the LLRP FacilityYLocationCm field.
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjInventoryConfiguration for LLRP parameter ImpinjInventoryConfiguration.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubConnectedType getConnected(void)
Get accessor functions for the LLRP Connected field.
llrp_u16_t getBitPointer(void)
Get accessor functions for the LLRP BitPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setType(EImpinjAntennaPolarizationType value)
Set accessor functions for the LLRP Type field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLoopSpec for LLRP parameter ImpinjLoopSpec.
Class Definition CImpinjSubRegulatoryRegion for LLRP parameter ImpinjSubRegulatoryRegion.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjTransmitPower for LLRP parameter ImpinjTransmitPower.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getControlData(void)
Get accessor functions for the LLRP ControlData field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getLastSeenSectorID(void)
Get accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConnected(EImpinjHubConnectedType value)
Set accessor functions for the LLRP Connected field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModelName(llrp_utf8v_t value)
Set accessor functions for the LLRP ModelName field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setBeaconState(llrp_u1_t value)
Set accessor functions for the LLRP BeaconState field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjFixedFrequencyList for LLRP parameter ImpinjFixedFrequencyList.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CIMPINJ_ENABLE_EXTENSIONS_RESPONSE for LLRP message IMPINJ_ENABLE_EXTENSIONS_RESPONS...
Class Definition CImpinjTiltConfiguration for LLRP parameter ImpinjTiltConfiguration.
llrp_u16v_t getTID(void)
Get accessor functions for the LLRP TID field.
void setSupportsTISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTISpecs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
llrp_s32_t getZAxis(void)
Get accessor functions for the LLRP ZAxis field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getReadCount(void)
Get accessor functions for the LLRP ReadCount field.
void setRFMode(EImpinjDirectionRFMode value)
Set accessor functions for the LLRP RFMode field.
void setResult(EImpinjMarginReadResultType value)
Set accessor functions for the LLRP Result field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
CImpinjEnableRFPhaseAngle * getImpinjEnableRFPhaseAngle(void)
Get accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearImpinjArrayVersion(void)
Clears the LLRP ImpinjArrayVersion sub-parameter list.
EImpinjDirectionFieldOfView getFieldOfView(void)
Get accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEnableAntennaAttemptNotification(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaAttemptNotification field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16v_t getEnabledSectorIDs(void)
Get accessor functions for the LLRP EnabledSectorIDs field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaEventDisconnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventDisconnected field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjRFPowerSweep for LLRP parameter ImpinjRFPowerSweep.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRFDopplerFrequencyMode(EImpinjRFDopplerFrequencyMode value)
Set accessor functions for the LLRP RFDopplerFrequencyMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
Class Definition CImpinjAntennaPolarizationCapability for LLRP parameter ImpinjAntennaPolarizationCap...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
CImpinjGGASentence * getImpinjGGASentence(void)
Get accessor functions for the LLRP ImpinjGGASentence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSupportsDISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsDISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjReducedPowerMode getReducedPowerMode(void)
Get accessor functions for the LLRP ReducedPowerMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjDisabledAntennas * getImpinjDisabledAntennas(void)
Get accessor functions for the LLRP ImpinjDisabledAntennas sub-parameter.
void setResult(EImpinjGetBlockPermalockStatusResultType value)
Set accessor functions for the LLRP Result field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjTxPower for LLRP parameter ImpinjTxPower.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
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.
void setTagFilterVerificationMode(EImpinjTagFilterVerificationMode value)
Set accessor functions for the LLRP TagFilterVerificationMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
llrp_u1_t getEnableAntennaAttemptNotification(void)
Get accessor functions for the LLRP EnableAntennaAttemptNotification field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjBLEVersion for LLRP parameter ImpinjBLEVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSendRep(llrp_u1_t value)
Set accessor functions for the LLRP SendRep field.
EImpinjAuthenticateResultType getResult(void)
Get accessor functions for the LLRP Result field.
Class Definition CImpinjLocationReportData for LLRP parameter ImpinjLocationReportData.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLinkMonitorMode getLinkMonitorMode(void)
Get accessor functions for the LLRP LinkMonitorMode field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setTxPowerReportingMode(EImpinjTxPowerReportingModeEnum value)
Set accessor functions for the LLRP TxPowerReportingMode field.
void setGPIDebounceTimerMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPIDebounceTimerMSec field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getEnableRFPowerSweep(void)
Get accessor functions for the LLRP EnableRFPowerSweep field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFPhaseAngleMode getRFPhaseAngleMode(void)
Get accessor functions for the LLRP RFPhaseAngleMode field.
EImpinjTxPowerReportingModeEnum getTxPowerReportingMode(void)
Get accessor functions for the LLRP TxPowerReportingMode field.
Class Definition CImpinjDirectionConfig for LLRP parameter ImpinjDirectionConfig. ...
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjGetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPolarizationControl for LLRP parameter ImpinjPolarizationControl.
void setFixedFrequencyMode(EImpinjFixedFrequencyMode value)
Set accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjReportBufferConfiguration for LLRP parameter ImpinjReportBufferConfiguration...
void enrollImpinjTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Impinj into the LTKCPP registry.
llrp_u16_t getPowerLevelStepSize(void)
Get accessor functions for the LLRP PowerLevelStepSize field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnableSelectGapClose(llrp_u1_t value)
Set accessor functions for the LLRP EnableSelectGapClose field.
void setFacilityYLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityYLocationCm field.
CImpinjDirectionReporting * getImpinjDirectionReporting(void)
Get accessor functions for the LLRP ImpinjDirectionReporting sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setReadCount(llrp_u16_t value)
Set accessor functions for the LLRP ReadCount field.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaEventHysteresis for LLRP parameter ImpinjAntennaEventHysteresis.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLowDutyCycle for LLRP parameter ImpinjLowDutyCycle.
void setPhaseAngle(llrp_u16_t value)
Set accessor functions for the LLRP PhaseAngle field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode
Error result codes for LTK operations.
Definition: ltkcpp_base.h:583
EImpinjDirectionReportType getType(void)
Get accessor functions for the LLRP Type field.
void setMask(llrp_u16v_t value)
Set accessor functions for the LLRP Mask field.
std::list< CImpinjArrayVersion * >::iterator beginImpinjArrayVersion(void)
Returns the first element of the ImpinjArrayVersion sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAuthenticate for LLRP parameter ImpinjAuthenticate.
void setFacilityXLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityXLocationCm field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjTIDParity * getImpinjTIDParity(void)
Get accessor functions for the LLRP ImpinjTIDParity sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPeakRSSI for LLRP parameter ImpinjPeakRSSI.
CImpinjLocationReportData * getImpinjLocationReportData(void)
Get accessor functions for the LLRP ImpinjLocationReportData sub-parameter.
llrp_u16_t getEmptyFieldTimeout(void)
Get accessor functions for the LLRP EmptyFieldTimeout field.
void setYAxis(llrp_s32_t value)
Set accessor functions for the LLRP YAxis field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAdvancedGPOMode getGPOMode(void)
Get accessor functions for the LLRP GPOMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setRMCSentence(llrp_utf8v_t value)
Set accessor functions for the LLRP RMCSentence field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjBlockPermalockResultType value)
Set accessor functions for the LLRP Result field.
CImpinjDirectionReportData * getImpinjDirectionReportData(void)
Get accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void setZAxis(llrp_s32_t value)
Set accessor functions for the LLRP ZAxis field.
llrp_u32_t getGPOPulseDurationMSec(void)
Get accessor functions for the LLRP GPOPulseDurationMSec field.
void setReportBufferMode(EImpinjReportBufferMode value)
Set accessor functions for the LLRP ReportBufferMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjBlockWriteWordCount for LLRP parameter ImpinjBlockWriteWordCount.
void setFirstSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP FirstSeenTimestampUTC field.
void setLongitude(llrp_s32_t value)
Set accessor functions for the LLRP Longitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator beginImpinjAntennaPolarizationCapability(void)
Returns the first element of the ImpinjAntennaPolarizationCapability sub-parameter list...
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
CImpinjDirectionUserTagPopulationLimit * getImpinjDirectionUserTagPopulationLimit(void)
Get accessor functions for the LLRP ImpinjDirectionUserTagPopulationLimit sub-parameter.
Class Definition CImpinjGGASentence for LLRP parameter ImpinjGGASentence.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getSystemTagPopulationLimitHighPerformance(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
Class Definition CImpinjLocationReporting for LLRP parameter ImpinjLocationReporting.
Class Definition CImpinjDisabledAntennas for LLRP parameter ImpinjDisabledAntennas.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjRFPhaseAngle for LLRP parameter ImpinjRFPhaseAngle.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearC1G2Read(void)
Clears the LLRP C1G2Read sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s16_t getTemperature(void)
Get accessor functions for the LLRP Temperature field.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS for LLRP message IMPINJ_SAVE_SETTINGS.
void setPolarizationControlEnabled(llrp_u1_t value)
Set accessor functions for the LLRP PolarizationControlEnabled field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getGen2v2TagsOnly(void)
Get accessor functions for the LLRP Gen2v2TagsOnly field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u1_t getSendRep(void)
Get accessor functions for the LLRP SendRep field.
void setRFPhaseAngleMode(EImpinjRFPhaseAngleMode value)
Set accessor functions for the LLRP RFPhaseAngleMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setResult(EImpinjGetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjEnablePeakRSSI for LLRP parameter ImpinjEnablePeakRSSI.
Class Definition CImpinjBeaconConfiguration for LLRP parameter ImpinjBeaconConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setLinkDownThreshold(llrp_u16_t value)
Set accessor functions for the LLRP LinkDownThreshold field.
Class Definition CImpinjGPSNMEASentences for LLRP parameter ImpinjGPSNMEASentences.
Class Definition CImpinjDiagnosticReport for LLRP parameter ImpinjDiagnosticReport.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjDirectionTagPopulationStatus getTagPopulationStatus(void)
Get accessor functions for the LLRP TagPopulationStatus field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setPersistence(EImpinjQTPersistence value)
Set accessor functions for the LLRP Persistence field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocYCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
llrp_u32v_t getConfidenceData(void)
Get accessor functions for the LLRP ConfidenceData field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLowDutyCycleMode(EImpinjLowDutyCycleMode value)
Set accessor functions for the LLRP LowDutyCycleMode field.
llrp_u16v_t getMask(void)
Get accessor functions for the LLRP Mask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjIntelligentAntennaMode getManagementEnabled(void)
Get accessor functions for the LLRP ManagementEnabled field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjxArrayCapabilities for LLRP parameter ImpinjxArrayCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjBlockPermalockOpSpecResult for LLRP parameter ImpinjBlockPermalockOpSpecResul...
CImpinjRMCSentence * getImpinjRMCSentence(void)
Get accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjArrayVersion for LLRP parameter ImpinjArrayVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getMinimumPowerLevel(void)
Get accessor functions for the LLRP MinimumPowerLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjBlockPermalock for LLRP parameter ImpinjBlockPermalock.
void setBitPointer(llrp_u16_t value)
Set accessor functions for the LLRP BitPointer field.
llrp_u64_t getAntennaEventConnected(void)
Get accessor functions for the LLRP AntennaEventConnected field.
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.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
llrp_u1_t getSupportsTISpecs(void)
Get accessor functions for the LLRP SupportsTISpecs field.
Class Definition CImpinjInventorySearchMode for LLRP parameter ImpinjInventorySearchMode.
llrp_u16_t getSystemTagPopulationLimitHighSensitivity(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjSetQTConfig for LLRP parameter ImpinjSetQTConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
void setGen2v2TagsOnly(llrp_u1_t value)
Set accessor functions for the LLRP Gen2v2TagsOnly field.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
Class Definition CImpinjAuthenticateOpSpecResult for LLRP parameter ImpinjAuthenticateOpSpecResult.
void setDopplerFrequency(llrp_s16_t value)
Set accessor functions for the LLRP DopplerFrequency field.
void setEnableRFPowerSweep(llrp_u1_t value)
Set accessor functions for the LLRP EnableRFPowerSweep field.
llrp_u16v_t getPermalockStatus(void)
Get accessor functions for the LLRP PermalockStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setHeightCm(llrp_u16_t value)
Set accessor functions for the LLRP HeightCm field.
llrp_u1_t getSupportsDISpecs(void)
Get accessor functions for the LLRP SupportsDISpecs field.
void setResult(EImpinjAuthenticateResultType value)
Set accessor functions for the LLRP Result field.
void setCSI(llrp_u8_t value)
Set accessor functions for the LLRP CSI field.
llrp_u32_t getMaxNumSectors(void)
Get accessor functions for the LLRP MaxNumSectors field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setInventorySearchMode(EImpinjInventorySearchType value)
Set accessor functions for the LLRP InventorySearchMode field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjRequestedDataType getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void setControlData(llrp_u32v_t value)
Set accessor functions for the LLRP ControlData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
void setAntennaIDOffset(llrp_u16_t value)
Set accessor functions for the LLRP AntennaIDOffset field.
void setFPGAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FPGAVersion field.
void setLatitude(llrp_s32_t value)
Set accessor functions for the LLRP Latitude field.
void setRequestedData(EImpinjRequestedDataType value)
Set accessor functions for the LLRP RequestedData field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getBitLength(void)
Get accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setEnableAntDwellTimeLimit(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntDwellTimeLimit field.
Class Definition CEPCData for LLRP parameter EPCData.
llrp_u16_t getComputeWindowSeconds(void)
Get accessor functions for the LLRP ComputeWindowSeconds field.
void setType(EImpinjLocationReportType value)
Set accessor functions for the LLRP Type field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s16_t getDopplerFrequency(void)
Get accessor functions for the LLRP DopplerFrequency field.
Class Definition CImpinjTruncatedReplyConfiguration for LLRP parameter ImpinjTruncatedReplyConfigurat...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void setPowerLevelStepSize(llrp_u16_t value)
Set accessor functions for the LLRP PowerLevelStepSize field.
EImpinjMarginReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaIDOffset(void)
Get accessor functions for the LLRP AntennaIDOffset field.
void setGPOMode(EImpinjAdvancedGPOMode value)
Set accessor functions for the LLRP GPOMode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
llrp_u1v_t getMessage(void)
Get accessor functions for the LLRP Message field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
Class Definition CImpinjEnableTxPower for LLRP parameter ImpinjEnableTxPower.
llrp_u16_t getFieldPingInterval(void)
Get accessor functions for the LLRP FieldPingInterval field.
Class Definition CImpinjEnableSerializedTID for LLRP parameter ImpinjEnableSerializedTID.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
llrp_u16_t getTxPower(void)
Get accessor functions for the LLRP TxPower field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHubID(void)
Get accessor functions for the LLRP HubID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrderingMode(EImpinjAccessSpecOrderingMode value)
Set accessor functions for the LLRP OrderingMode field.
llrp_u16_t getPhaseAngle(void)
Get accessor functions for the LLRP PhaseAngle field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
CImpinjC1G2DirectionConfig * getImpinjC1G2DirectionConfig(void)
Get accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
llrp_u16_t getBlockRange(void)
Get accessor functions for the LLRP BlockRange field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator endImpinjAntennaPolarizationCapability(void)
Returns the last element of the ImpinjAntennaPolarizationCapability sub-parameter list...
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u1_t getPolarizationControlEnabled(void)
Get accessor functions for the LLRP PolarizationControlEnabled field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRSSI(llrp_s16_t value)
Set accessor functions for the LLRP RSSI field.
Class Definition CImpinjDetailedVersion for LLRP parameter ImpinjDetailedVersion. ...
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjGPSCoordinates for LLRP parameter ImpinjGPSCoordinates.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
Class Definition CImpinjReaderTemperature for LLRP parameter ImpinjReaderTemperature.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjEnableRFDopplerFrequency for LLRP parameter ImpinjEnableRFDopplerFrequency.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjHubVersions for LLRP parameter ImpinjHubVersions.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjFixedFrequencyMode getFixedFrequencyMode(void)
Get accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjOpSpecRetryCount for LLRP parameter ImpinjOpSpecRetryCount.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjxArrayDirectionCapabilities * getImpinjxArrayDirectionCapabilities(void)
Get accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getIncRepLen(void)
Get accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
void setSupportsTSISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTSISpecs field.
void setTagPopulationStatus(EImpinjDirectionTagPopulationStatus value)
Set accessor functions for the LLRP TagPopulationStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
int countEPCData(void)
Count of the LLRP EPCData sub-parameter list.
void setFrequencyList(llrp_u32v_t value)
Set accessor functions for the LLRP FrequencyList field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjDirectionReporting for LLRP parameter ImpinjDirectionReporting.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u32_t getLoopCount(void)
Get accessor functions for the LLRP LoopCount field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
llrp_u1_t getSaveConfiguration(void)
Get accessor functions for the LLRP SaveConfiguration field.
Class Definition CImpinjGetBlockPermalockStatus for LLRP parameter ImpinjGetBlockPermalockStatus.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setDiagnosticReportLevel(EImpinjDirectionDiagnosticReportLevel value)
Set accessor functions for the LLRP DiagnosticReportLevel field.
void clearEPCData(void)
Clears the LLRP EPCData sub-parameter list.
std::list< CImpinjArrayVersion * >::iterator endImpinjArrayVersion(void)
Returns the last element of the ImpinjArrayVersion sub-parameter list.
Class Definition CImpinjTIDParity for LLRP parameter ImpinjTIDParity.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjArrayVersion(void)
Count of the LLRP ImpinjArrayVersion sub-parameter list.
llrp_utf8v_t getGGASentence(void)
Get accessor functions for the LLRP GGASentence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjGetBlockPermalockStatusResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u1_t getEnableSelectGapClose(void)
Get accessor functions for the LLRP EnableSelectGapClose field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u64_t getBeaconDurationSeconds(void)
Get accessor functions for the LLRP BeaconDurationSeconds field.
void setBeaconDurationSeconds(llrp_u64_t value)
Set accessor functions for the LLRP BeaconDurationSeconds field.
void setRetryCount(llrp_u16_t value)
Set accessor functions for the LLRP RetryCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setMinimumPowerLevel(llrp_u16_t value)
Set accessor functions for the LLRP MinimumPowerLevel field.
EImpinjQTPersistence getPersistence(void)
Get accessor functions for the LLRP Persistence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
void setFault(EImpinjHubFaultType value)
Set accessor functions for the LLRP Fault field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjSerializedTIDMode getSerializedTIDMode(void)
Get accessor functions for the LLRP SerializedTIDMode field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjLocationReporting * getImpinjLocationReporting(void)
Get accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
void setComputeWindowSeconds(llrp_u16_t value)
Set accessor functions for the LLRP ComputeWindowSeconds field.
void setGGASentence(llrp_utf8v_t value)
Set accessor functions for the LLRP GGASentence field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConfidenceData(llrp_u32v_t value)
Set accessor functions for the LLRP ConfidenceData field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjAntennaAttemptEvent for LLRP parameter ImpinjAntennaAttemptEvent.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
llrp_u1_t getEnableAntDwellTimeLimit(void)
Get accessor functions for the LLRP EnableAntDwellTimeLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjEnableGPSCoordinates * getImpinjEnableGPSCoordinates(void)
Get accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrientationDegrees(llrp_s16_t value)
Set accessor functions for the LLRP OrientationDegrees field.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setHubID(llrp_u16_t value)
Set accessor functions for the LLRP HubID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableOptimizedRead * getImpinjEnableOptimizedRead(void)
Get accessor functions for the LLRP ImpinjEnableOptimizedRead sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getFPGAVersion(void)
Get accessor functions for the LLRP FPGAVersion field.
CImpinjDirectionSectors * getImpinjDirectionSectors(void)
Get accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
EImpinjRegulatoryRegion getRegulatoryRegion(void)
Get accessor functions for the LLRP RegulatoryRegion field.
Class Definition CImpinjAdvancedGPOConfiguration for LLRP parameter ImpinjAdvancedGPOConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getGPIDebounceTimerMSec(void)
Get accessor functions for the LLRP GPIDebounceTimerMSec field.
void setIncRepLen(llrp_u1_t value)
Set accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjSetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjLocationConfidence for LLRP parameter ImpinjLocationConfidence.
Class Definition CImpinjRFDopplerFrequency for LLRP parameter ImpinjRFDopplerFrequency.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUserTagPopulationLimit(llrp_u16_t value)
Set accessor functions for the LLRP UserTagPopulationLimit field.
llrp_utf8v_t getSoftwareVersion(void)
Get accessor functions for the LLRP SoftwareVersion field.
EImpinjLocationReportType getType(void)
Get accessor functions for the LLRP Type field.
void setResponse(llrp_u1v_t value)
Set accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16v_t getBlockMask(void)
Get accessor functions for the LLRP BlockMask field.
EImpinjBlockPermalockResultType getResult(void)
Get accessor functions for the LLRP Result field.
EImpinjAntennaPolarizationType getType(void)
Get accessor functions for the LLRP Type field.
Class Definition CImpinjDirectionUserTagPopulationLimit for LLRP parameter ImpinjDirectionUserTagPopu...
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getLocXCentimeters(void)
Get accessor functions for the LLRP LocXCentimeters field.
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 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.
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.
Class Definition CImpinjAccessSpecConfiguration for LLRP parameter ImpinjAccessSpecConfiguration.
Class Definition CImpinjFrequencyCapabilities for LLRP parameter ImpinjFrequencyCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnabledSectorIDs(llrp_u16v_t value)
Set accessor functions for the LLRP EnabledSectorIDs field.
void clearImpinjAntennaPolarizationCapability(void)
Clears the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
Class Definition CImpinjLinkMonitorConfiguration for LLRP parameter ImpinjLinkMonitorConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator endEPCData(void)
Returns the last element of the EPCData sub-parameter list.
CImpinjLocationConfidence * getImpinjLocationConfidence(void)
Get accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjMarginReadOpSpecResult for LLRP parameter ImpinjMarginReadOpSpecResult.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setManagementEnabled(EImpinjIntelligentAntennaMode value)
Set accessor functions for the LLRP ManagementEnabled field.
void setGPOPulseDurationMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPOPulseDurationMSec field.
Class Definition CImpinjxArrayDirectionCapabilities for LLRP parameter ImpinjxArrayDirectionCapabilit...
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaConfiguration for LLRP parameter ImpinjAntennaConfiguration.
EImpinjGPSCoordinatesMode getGPSCoordinatesMode(void)
Get accessor functions for the LLRP GPSCoordinatesMode field.
CImpinjAntennaEventConfiguration * getImpinjAntennaEventConfiguration(void)
Get accessor functions for the LLRP ImpinjAntennaEventConfiguration sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjHubConfiguration for LLRP parameter ImpinjHubConfiguration.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBitLength(llrp_u8_t value)
Set accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getSupportsTSISpecs(void)
Get accessor functions for the LLRP SupportsTSISpecs field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjReportBufferMode getReportBufferMode(void)
Get accessor functions for the LLRP ReportBufferMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getXAxis(void)
Get accessor functions for the LLRP XAxis field.
Class Definition CImpinjDirectionDiagnosticData for LLRP parameter ImpinjDirectionDiagnosticData.
void setLinkMonitorMode(EImpinjLinkMonitorMode value)
Set accessor functions for the LLRP LinkMonitorMode field.
Class Definition CImpinjEnableRFPhaseAngle for LLRP parameter ImpinjEnableRFPhaseAngle.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS_RESPONSE for LLRP message IMPINJ_SAVE_SETTINGS_RESPONSE.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_s16_t getOrientationDegrees(void)
Get accessor functions for the LLRP OrientationDegrees field.
Class Definition CImpinjExtendedTagInformation for LLRP parameter ImpinjExtendedTagInformation.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjDirectionDiagnosticReportLevel getDiagnosticReportLevel(void)
Get accessor functions for the LLRP DiagnosticReportLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFDopplerFrequencyMode getRFDopplerFrequencyMode(void)
Get accessor functions for the LLRP RFDopplerFrequencyMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
EImpinjInventorySearchType getInventorySearchMode(void)
Get accessor functions for the LLRP InventorySearchMode field.
EImpinjTagFilterVerificationMode getTagFilterVerificationMode(void)
Get accessor functions for the LLRP TagFilterVerificationMode field.
Class Definition CImpinjGetBlockPermalockStatusOpSpecResult for LLRP parameter ImpinjGetBlockPermaloc...
CImpinjEnableSerializedTID * getImpinjEnableSerializedTID(void)
Get accessor functions for the LLRP ImpinjEnableSerializedTID sub-parameter.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
Class Definition CImpinjAntennaEventConfiguration for LLRP parameter ImpinjAntennaEventConfiguration...
CImpinjBLEVersion * getImpinjBLEVersion(void)
Get accessor functions for the LLRP ImpinjBLEVersion sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
void setSupportsLISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsLISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLocYCentimeters(void)
Get accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLastSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setRegulatoryRegion(EImpinjRegulatoryRegion value)
Set accessor functions for the LLRP RegulatoryRegion field.
void setTID(llrp_u16v_t value)
Set accessor functions for the LLRP TID field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
Class Definition CImpinjAccessSpecOrdering for LLRP parameter ImpinjAccessSpecOrdering.
Class Definition CImpinjAntennaCapabilities for LLRP parameter ImpinjAntennaCapabilities.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjSerializedTID for LLRP parameter ImpinjSerializedTID.
llrp_s32_t getFacilityXLocationCm(void)
Get accessor functions for the LLRP FacilityXLocationCm field.
void setMessage(llrp_u1v_t value)
Set accessor functions for the LLRP Message field.
Class Definition CImpinjGPIDebounceConfiguration for LLRP parameter ImpinjGPIDebounceConfiguration.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjOptimizedReadMode getOptimizedReadMode(void)
Get accessor functions for the LLRP OptimizedReadMode field.
llrp_u1_t getSupportsLISpecs(void)
Get accessor functions for the LLRP SupportsLISpecs field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableRFDopplerFrequency * getImpinjEnableRFDopplerFrequency(void)
Get accessor functions for the LLRP ImpinjEnableRFDopplerFrequency sub-parameter. ...
llrp_u8_t getEPCLength(void)
Get accessor functions for the LLRP EPCLength field.
llrp_s16_t getRSSI(void)
Get accessor functions for the LLRP RSSI field.
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
void setFirstSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP FirstSeenSectorID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjAccessSpecOrdering * getImpinjAccessSpecOrdering(void)
Get accessor functions for the LLRP ImpinjAccessSpecOrdering sub-parameter.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHeightCm(void)
Get accessor functions for the LLRP HeightCm field.
void setParityError(llrp_u1_t value)
Set accessor functions for the LLRP ParityError field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
void setOptimizedReadMode(EImpinjOptimizedReadMode value)
Set accessor functions for the LLRP OptimizedReadMode field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setType(EImpinjDirectionReportType value)
Set accessor functions for the LLRP Type field.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u32v_t getFrequencyList(void)
Get accessor functions for the LLRP FrequencyList field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator beginEPCData(void)
Returns the first element of the EPCData sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjC1G2DirectionConfig for LLRP parameter ImpinjC1G2DirectionConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void setTemperature(llrp_s16_t value)
Set accessor functions for the LLRP Temperature field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
CImpinjEnablePeakRSSI * getImpinjEnablePeakRSSI(void)
Get accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
CImpinjEnableTxPower * getImpinjEnableTxPower(void)
Get accessor functions for the LLRP ImpinjEnableTxPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
CImpinjAntennaEventHysteresis * getImpinjAntennaEventHysteresis(void)
Get accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLoopCount(llrp_u32_t value)
Set accessor functions for the LLRP LoopCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
Class Definition CImpinjReducedPowerFrequencyList for LLRP parameter ImpinjReducedPowerFrequencyList...
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjDISpec for LLRP parameter ImpinjDISpec.
void setBlockRange(llrp_u16_t value)
Set accessor functions for the LLRP BlockRange field.
void setReducedPowerMode(EImpinjReducedPowerMode value)
Set accessor functions for the LLRP ReducedPowerMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1v_t getResponse(void)
Get accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u8_t getCSI(void)
Get accessor functions for the LLRP CSI field.
Class Definition CImpinjRMCSentence for LLRP parameter ImpinjRMCSentence.
EImpinjDirectionRFMode getRFMode(void)
Get accessor functions for the LLRP RFMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjAntennaPolarizationCapability(void)
Count of the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
Class Definition CImpinjEnableGPSCoordinates for LLRP parameter ImpinjEnableGPSCoordinates.
Class Definition CImpinjMarginRead for LLRP parameter ImpinjMarginRead.
void setPeakRSSIMode(EImpinjPeakRSSIMode value)
Set accessor functions for the LLRP PeakRSSIMode field.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjC1G2LocationConfig for LLRP parameter ImpinjC1G2LocationConfig.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEPCLength(llrp_u8_t value)
Set accessor functions for the LLRP EPCLength field.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEmptyFieldTimeout(llrp_u16_t value)
Set accessor functions for the LLRP EmptyFieldTimeout field.
void setAntennaEventConnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventConnected field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjLocationAlgorithmControl * getImpinjLocationAlgorithmControl(void)
Get accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.