LTKCPP-- LLRP Toolkit C Plus Plus Library
armv7l/src/generated/out_impinj_ltkcpp.h
1 
2 /*
3  * Generated file - DO NOT EDIT
4  *
5  * This is the header file for the LLRP Tool Kit (LTK)
6  * C++ (aka cpp) implementation. It is generated into a .inc file
7  * that is included by a platform specific .h header file.
8  * That .h file takes care of prerequisites needed by this file.
9  */
10 
11 
12 /*
13  * Message classes - forward decls
14  */
15 
16 
17 /* Custom messages */
18 
23 
24 /*
25  * Parameter classes - forward decls
26  */
27 
28 
29 /* Custom parameters */
30 
37 class CImpinjHubVersions;
50 class CImpinjSetQTConfig;
52 class CImpinjGetQTConfig;
61 class CImpinjPeakRSSI;
63 class CImpinjLoopSpec;
65 class CImpinjGGASentence;
66 class CImpinjRMCSentence;
75 class CImpinjTxPower;
87 class CImpinjLISpec;
93 class CImpinjDISpec;
109 class CImpinjTIDParity;
110 class CImpinjMarginRead;
112 class CImpinjBLEVersion;
114 class CImpinjRFPowerSweep;
116 class CImpinjAuthenticate;
118 
119 /*
120  * Vendor descriptor declarations.
121  */
122 
123 extern const CVendorDescriptor
124 g_vdescImpinj;
125 
126 
127 /*
128  * Namespace descriptor declarations.
129  */
130 
131 extern const CNamespaceDescriptor
132 g_nsdescImpinj;
133 
134 
135 /*
136  * Enumeration definitions and declarations of
137  * enumeration string tables.
138  */
139 
140 
172 enum EImpinjRequestedDataType
173 {
174 
175  ImpinjRequestedDataType_All_Capabilities = 1000,
176  ImpinjRequestedDataType_Impinj_Detailed_Version = 1001,
177  ImpinjRequestedDataType_Impinj_Frequency_Capabilities = 1002,
178  ImpinjRequestedDataType_Impinj_xArray_Capabilities = 1003,
179  ImpinjRequestedDataType_Impinj_Antenna_Capabilities = 1004,
180  ImpinjRequestedDataType_All_Configuration = 2000,
181  ImpinjRequestedDataType_Impinj_Sub_Regulatory_Region = 2001,
182  ImpinjRequestedDataType_Impinj_GPI_Debounce_Configuration = 2003,
183  ImpinjRequestedDataType_Impinj_Reader_Temperature = 2004,
184  ImpinjRequestedDataType_Impinj_Link_Monitor_Configuration = 2005,
185  ImpinjRequestedDataType_Impinj_Report_Buffer_Configuration = 2006,
186  ImpinjRequestedDataType_Impinj_Access_Spec_Configuration = 2007,
187  ImpinjRequestedDataType_Impinj_GPS_NMEA_Sentences = 2008,
188  ImpinjRequestedDataType_Impinj_Advanced_GPO_Configuration = 2009,
189  ImpinjRequestedDataType_Impinj_Tilt_Configuration = 2010,
190  ImpinjRequestedDataType_Impinj_Beacon_Configuration = 2011,
191  ImpinjRequestedDataType_Impinj_Antenna_Configuration = 2012,
192  ImpinjRequestedDataType_Impinj_Location_Configuration = 2013,
193  ImpinjRequestedDataType_Impinj_Transition_Configuration = 2014,
194  ImpinjRequestedDataType_Impinj_Hub_Configuration = 2015,
195  ImpinjRequestedDataType_Impinj_PolarizationControl_Configuration = 2017,
196  ImpinjRequestedDataType_Impinj_Direction_Configuration = 2018,
197 };
198 
199 extern const SEnumTableEntry
200 g_estImpinjRequestedDataType[];
201 
202 
240 enum EImpinjRegulatoryRegion
241 {
242 
243  ImpinjRegulatoryRegion_FCC_Part_15_247 = 0,
244  ImpinjRegulatoryRegion_ETSI_EN_300_220 = 1,
245  ImpinjRegulatoryRegion_ETSI_EN_302_208_With_LBT = 2,
246  ImpinjRegulatoryRegion_Hong_Kong_920_925_MHz = 3,
247  ImpinjRegulatoryRegion_Taiwan_922_928_MHz = 4,
248  ImpinjRegulatoryRegion_ETSI_EN_302_208_v1_2_1 = 7,
249  ImpinjRegulatoryRegion_Korea_917_921_MHz = 8,
250  ImpinjRegulatoryRegion_Malaysia_919_923_MHz = 9,
251  ImpinjRegulatoryRegion_China_920_925_MHz = 10,
252  ImpinjRegulatoryRegion_South_Africa_915_919_MHz = 12,
253  ImpinjRegulatoryRegion_Brazil_902_907_and_915_928_MHz = 13,
254  ImpinjRegulatoryRegion_Thailand_920_925_MHz = 14,
255  ImpinjRegulatoryRegion_Singapore_920_925_MHz = 15,
256  ImpinjRegulatoryRegion_Australia_920_926_MHz = 16,
257  ImpinjRegulatoryRegion_India_865_867_MHz = 17,
258  ImpinjRegulatoryRegion_Uruguay_916_928_MHz = 18,
259  ImpinjRegulatoryRegion_Vietnam_918_923_MHz = 19,
260  ImpinjRegulatoryRegion_Israel_915_917_MHz = 20,
261  ImpinjRegulatoryRegion_Philippines_918_920_MHz = 21,
262  ImpinjRegulatoryRegion_Vietnam_920_923_MHz = 22,
263  ImpinjRegulatoryRegion_Indonesia_920_923_MHz = 23,
264  ImpinjRegulatoryRegion_New_Zealand_921p5_928_MHz = 24,
265  ImpinjRegulatoryRegion_Japan_916_921_MHz_Without_LBT = 25,
266  ImpinjRegulatoryRegion_Latin_America_902_928_MHz = 26,
267  ImpinjRegulatoryRegion_Peru_916_928_MHz = 27,
268  ImpinjRegulatoryRegion_Bangladesh_925_927_MHz = 28,
269  ImpinjRegulatoryRegion_ETSI_915_921_MHz = 29,
270  ImpinjRegulatoryRegion_Morocco_867_868_MHz = 30,
271  ImpinjRegulatoryRegion_Paraguay_918_928_MHz = 31,
272  ImpinjRegulatoryRegion_Morocco = 32,
273 };
274 
275 extern const SEnumTableEntry
276 g_estImpinjRegulatoryRegion[];
277 
278 
293 enum EImpinjInventorySearchType
294 {
295 
296  ImpinjInventorySearchType_Reader_Selected = 0,
297  ImpinjInventorySearchType_Single_Target = 1,
298  ImpinjInventorySearchType_Dual_Target = 2,
299  ImpinjInventorySearchType_Single_Target_With_Suppression = 3,
300  ImpinjInventorySearchType_No_Target = 4,
301  ImpinjInventorySearchType_Single_Target_BtoA = 5,
302  ImpinjInventorySearchType_Dual_Target_with_BtoASelect = 6,
303 };
304 
305 extern const SEnumTableEntry
306 g_estImpinjInventorySearchType[];
307 
308 
319 enum EImpinjFixedFrequencyMode
320 {
321 
322  ImpinjFixedFrequencyMode_Disabled = 0,
323  ImpinjFixedFrequencyMode_Auto_Select = 1,
324  ImpinjFixedFrequencyMode_Channel_List = 2,
325 };
326 
327 extern const SEnumTableEntry
328 g_estImpinjFixedFrequencyMode[];
329 
330 
340 enum EImpinjReducedPowerMode
341 {
342 
343  ImpinjReducedPowerMode_Disabled = 0,
344  ImpinjReducedPowerMode_Enabled = 1,
345 };
346 
347 extern const SEnumTableEntry
348 g_estImpinjReducedPowerMode[];
349 
350 
360 enum EImpinjLowDutyCycleMode
361 {
362 
363  ImpinjLowDutyCycleMode_Disabled = 0,
364  ImpinjLowDutyCycleMode_Enabled = 1,
365 };
366 
367 extern const SEnumTableEntry
368 g_estImpinjLowDutyCycleMode[];
369 
370 
380 enum EImpinjLinkMonitorMode
381 {
382 
383  ImpinjLinkMonitorMode_Disabled = 0,
384  ImpinjLinkMonitorMode_Enabled = 1,
385 };
386 
387 extern const SEnumTableEntry
388 g_estImpinjLinkMonitorMode[];
389 
390 
400 enum EImpinjReportBufferMode
401 {
402 
403  ImpinjReportBufferMode_Normal = 0,
404  ImpinjReportBufferMode_Low_Latency = 1,
405 };
406 
407 extern const SEnumTableEntry
408 g_estImpinjReportBufferMode[];
409 
410 
425 enum EImpinjBlockPermalockResultType
426 {
427 
428  ImpinjBlockPermalockResultType_Success = 0,
429  ImpinjBlockPermalockResultType_Insufficient_Power = 1,
430  ImpinjBlockPermalockResultType_Nonspecific_Tag_Error = 2,
431  ImpinjBlockPermalockResultType_No_Response_From_Tag = 3,
432  ImpinjBlockPermalockResultType_Nonspecific_Reader_Error = 4,
433  ImpinjBlockPermalockResultType_Incorrect_Password_Error = 5,
434  ImpinjBlockPermalockResultType_Tag_Memory_Overrun_Error = 6,
435 };
436 
437 extern const SEnumTableEntry
438 g_estImpinjBlockPermalockResultType[];
439 
440 
454 enum EImpinjGetBlockPermalockStatusResultType
455 {
456 
457  ImpinjGetBlockPermalockStatusResultType_Success = 0,
458  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Tag_Error = 1,
459  ImpinjGetBlockPermalockStatusResultType_No_Response_From_Tag = 2,
460  ImpinjGetBlockPermalockStatusResultType_Nonspecific_Reader_Error = 3,
461  ImpinjGetBlockPermalockStatusResultType_Incorrect_Password_Error = 4,
462  ImpinjGetBlockPermalockStatusResultType_Tag_Memory_Overrun_Error = 5,
463 };
464 
465 extern const SEnumTableEntry
466 g_estImpinjGetBlockPermalockStatusResultType[];
467 
468 
479 enum EImpinjQTDataProfile
480 {
481 
482  ImpinjQTDataProfile_Unknown = 0,
483  ImpinjQTDataProfile_Private = 1,
484  ImpinjQTDataProfile_Public = 2,
485 };
486 
487 extern const SEnumTableEntry
488 g_estImpinjQTDataProfile[];
489 
490 
501 enum EImpinjQTAccessRange
502 {
503 
504  ImpinjQTAccessRange_Unknown = 0,
505  ImpinjQTAccessRange_Normal_Range = 1,
506  ImpinjQTAccessRange_Short_Range = 2,
507 };
508 
509 extern const SEnumTableEntry
510 g_estImpinjQTAccessRange[];
511 
512 
523 enum EImpinjQTPersistence
524 {
525 
526  ImpinjQTPersistence_Unknown = 0,
527  ImpinjQTPersistence_Temporary = 1,
528  ImpinjQTPersistence_Permanent = 2,
529 };
530 
531 extern const SEnumTableEntry
532 g_estImpinjQTPersistence[];
533 
534 
548 enum EImpinjSetQTConfigResultType
549 {
550 
551  ImpinjSetQTConfigResultType_Success = 0,
552  ImpinjSetQTConfigResultType_Insufficient_Power = 1,
553  ImpinjSetQTConfigResultType_Nonspecific_Tag_Error = 2,
554  ImpinjSetQTConfigResultType_No_Response_From_Tag = 3,
555  ImpinjSetQTConfigResultType_Nonspecific_Reader_Error = 4,
556  ImpinjSetQTConfigResultType_Incorrect_Password_Error = 5,
557 };
558 
559 extern const SEnumTableEntry
560 g_estImpinjSetQTConfigResultType[];
561 
562 
575 enum EImpinjGetQTConfigResultType
576 {
577 
578  ImpinjGetQTConfigResultType_Success = 0,
579  ImpinjGetQTConfigResultType_Nonspecific_Tag_Error = 1,
580  ImpinjGetQTConfigResultType_No_Response_From_Tag = 2,
581  ImpinjGetQTConfigResultType_Nonspecific_Reader_Error = 3,
582  ImpinjGetQTConfigResultType_Incorrect_Password_Error = 4,
583 };
584 
585 extern const SEnumTableEntry
586 g_estImpinjGetQTConfigResultType[];
587 
588 
598 enum EImpinjSerializedTIDMode
599 {
600 
601  ImpinjSerializedTIDMode_Disabled = 0,
602  ImpinjSerializedTIDMode_Enabled = 1,
603 };
604 
605 extern const SEnumTableEntry
606 g_estImpinjSerializedTIDMode[];
607 
608 
618 enum EImpinjRFPhaseAngleMode
619 {
620 
621  ImpinjRFPhaseAngleMode_Disabled = 0,
622  ImpinjRFPhaseAngleMode_Enabled = 1,
623 };
624 
625 extern const SEnumTableEntry
626 g_estImpinjRFPhaseAngleMode[];
627 
628 
638 enum EImpinjPeakRSSIMode
639 {
640 
641  ImpinjPeakRSSIMode_Disabled = 0,
642  ImpinjPeakRSSIMode_Enabled = 1,
643 };
644 
645 extern const SEnumTableEntry
646 g_estImpinjPeakRSSIMode[];
647 
648 
658 enum EImpinjGPSCoordinatesMode
659 {
660 
661  ImpinjGPSCoordinatesMode_Disabled = 0,
662  ImpinjGPSCoordinatesMode_Enabled = 1,
663 };
664 
665 extern const SEnumTableEntry
666 g_estImpinjGPSCoordinatesMode[];
667 
668 
683 enum EImpinjAdvancedGPOMode
684 {
685 
686  ImpinjAdvancedGPOMode_Normal = 0,
687  ImpinjAdvancedGPOMode_Pulsed = 1,
688  ImpinjAdvancedGPOMode_Reader_Operational_Status = 2,
689  ImpinjAdvancedGPOMode_LLRP_Connection_Status = 3,
690  ImpinjAdvancedGPOMode_Reader_Inventory_Status = 4,
691  ImpinjAdvancedGPOMode_Network_Connection_Status = 5,
692  ImpinjAdvancedGPOMode_Reader_Inventory_Tags_Status = 6,
693 };
694 
695 extern const SEnumTableEntry
696 g_estImpinjAdvancedGPOMode[];
697 
698 
708 enum EImpinjOptimizedReadMode
709 {
710 
711  ImpinjOptimizedReadMode_Disabled = 0,
712  ImpinjOptimizedReadMode_Enabled = 1,
713 };
714 
715 extern const SEnumTableEntry
716 g_estImpinjOptimizedReadMode[];
717 
718 
728 enum EImpinjAccessSpecOrderingMode
729 {
730 
731  ImpinjAccessSpecOrderingMode_FIFO = 0,
732  ImpinjAccessSpecOrderingMode_Ascending = 1,
733 };
734 
735 extern const SEnumTableEntry
736 g_estImpinjAccessSpecOrderingMode[];
737 
738 
748 enum EImpinjRFDopplerFrequencyMode
749 {
750 
751  ImpinjRFDopplerFrequencyMode_Disabled = 0,
752  ImpinjRFDopplerFrequencyMode_Enabled = 1,
753 };
754 
755 extern const SEnumTableEntry
756 g_estImpinjRFDopplerFrequencyMode[];
757 
758 
768 enum EImpinjTxPowerReportingModeEnum
769 {
770 
771  ImpinjTxPowerReportingModeEnum_Disabled = 0,
772  ImpinjTxPowerReportingModeEnum_Enabled = 1,
773 };
774 
775 extern const SEnumTableEntry
776 g_estImpinjTxPowerReportingModeEnum[];
777 
778 
789 enum EImpinjHubConnectedType
790 {
791 
792  ImpinjHubConnectedType_Unknown = 0,
793  ImpinjHubConnectedType_Disconnected = 1,
794  ImpinjHubConnectedType_Connected = 2,
795 };
796 
797 extern const SEnumTableEntry
798 g_estImpinjHubConnectedType[];
799 
800 
817 enum EImpinjHubFaultType
818 {
819 
820  ImpinjHubFaultType_No_Fault = 0,
821  ImpinjHubFaultType_RF_Power = 1,
822  ImpinjHubFaultType_RF_Power_On_Hub_1 = 2,
823  ImpinjHubFaultType_RF_Power_On_Hub_2 = 3,
824  ImpinjHubFaultType_RF_Power_On_Hub_3 = 4,
825  ImpinjHubFaultType_RF_Power_On_Hub_4 = 5,
826  ImpinjHubFaultType_No_Init = 6,
827  ImpinjHubFaultType_Serial_Overflow = 7,
828  ImpinjHubFaultType_Disconnected = 8,
829 };
830 
831 extern const SEnumTableEntry
832 g_estImpinjHubFaultType[];
833 
834 
845 enum EImpinjLocationReportType
846 {
847 
848  ImpinjLocationReportType_Entry = 0,
849  ImpinjLocationReportType_Update = 1,
850  ImpinjLocationReportType_Exit = 2,
851 };
852 
853 extern const SEnumTableEntry
854 g_estImpinjLocationReportType[];
855 
856 
900 enum EImpinjDirectionFieldOfView
901 {
902 
903  ImpinjDirectionFieldOfView_ReaderSelected = 0,
904  ImpinjDirectionFieldOfView_Wide = 1,
905  ImpinjDirectionFieldOfView_Narrow = 2,
906 };
907 
908 extern const SEnumTableEntry
909 g_estImpinjDirectionFieldOfView[];
910 
911 
946 enum EImpinjDirectionRFMode
947 {
948 
949  ImpinjDirectionRFMode_HighSensitivity = 0,
950  ImpinjDirectionRFMode_HighPerformance = 1,
951 };
952 
953 extern const SEnumTableEntry
954 g_estImpinjDirectionRFMode[];
955 
956 
1006 enum EImpinjDirectionDiagnosticReportLevel
1007 {
1008 
1009  ImpinjDirectionDiagnosticReportLevel_Off = 0,
1010  ImpinjDirectionDiagnosticReportLevel_Basic = 1,
1011  ImpinjDirectionDiagnosticReportLevel_Extended = 2,
1012  ImpinjDirectionDiagnosticReportLevel_Debug = 3,
1013 };
1014 
1015 extern const SEnumTableEntry
1016 g_estImpinjDirectionDiagnosticReportLevel[];
1017 
1018 
1057 enum EImpinjDirectionReportType
1058 {
1059 
1060  ImpinjDirectionReportType_Entry = 0,
1061  ImpinjDirectionReportType_Update = 1,
1062  ImpinjDirectionReportType_Exit = 2,
1063 };
1064 
1065 extern const SEnumTableEntry
1066 g_estImpinjDirectionReportType[];
1067 
1068 
1107 enum EImpinjDirectionTagPopulationStatus
1108 {
1109 
1110  ImpinjDirectionTagPopulationStatus_OK = 0,
1111  ImpinjDirectionTagPopulationStatus_UserOverflow = 1,
1112  ImpinjDirectionTagPopulationStatus_SystemOverflow = 2,
1113 };
1114 
1115 extern const SEnumTableEntry
1116 g_estImpinjDirectionTagPopulationStatus[];
1117 
1118 
1128 enum EImpinjIntelligentAntennaMode
1129 {
1130 
1131  ImpinjIntelligentAntennaMode_Disabled = 0,
1132  ImpinjIntelligentAntennaMode_Enabled = 1,
1133 };
1134 
1135 extern const SEnumTableEntry
1136 g_estImpinjIntelligentAntennaMode[];
1137 
1138 
1150 enum EImpinjAntennaPolarizationType
1151 {
1152 
1153  ImpinjAntennaPolarizationType_LinearHorizontal = 0,
1154  ImpinjAntennaPolarizationType_LinearVertical = 1,
1155  ImpinjAntennaPolarizationType_CircularRight = 2,
1156  ImpinjAntennaPolarizationType_CircularLeft = 3,
1157 };
1158 
1159 extern const SEnumTableEntry
1160 g_estImpinjAntennaPolarizationType[];
1161 
1162 
1179 enum EImpinjMarginReadResultType
1180 {
1181 
1182  ImpinjMarginReadResultType_Success = 0,
1183  ImpinjMarginReadResultType_Failure = 1,
1184  ImpinjMarginReadResultType_Insufficient_Power = 2,
1185  ImpinjMarginReadResultType_Nonspecific_Tag_Error = 3,
1186  ImpinjMarginReadResultType_No_Response_From_Tag = 4,
1187  ImpinjMarginReadResultType_Nonspecific_Reader_Error = 5,
1188  ImpinjMarginReadResultType_Incorrect_Password_Error = 6,
1189  ImpinjMarginReadResultType_Tag_Memory_Overrun_Error = 7,
1190  ImpinjMarginReadResultType_Tag_Memory_Locked_Error = 8,
1191 };
1192 
1193 extern const SEnumTableEntry
1194 g_estImpinjMarginReadResultType[];
1195 
1196 
1210 enum EImpinjAuthenticateResultType
1211 {
1212 
1213  ImpinjAuthenticateResultType_Success = 0,
1214  ImpinjAuthenticateResultType_Insufficient_Power = 1,
1215  ImpinjAuthenticateResultType_Not_Supported_Error = 2,
1216  ImpinjAuthenticateResultType_Nonspecific_Tag_Error = 3,
1217  ImpinjAuthenticateResultType_Nonspecific_Reader_Error = 4,
1218  ImpinjAuthenticateResultType_No_Response_From_Tag = 5,
1219 };
1220 
1221 extern const SEnumTableEntry
1222 g_estImpinjAuthenticateResultType[];
1223 
1224 
1230 
1254 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1255 {
1256  public:
1258  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1259 
1262 
1263  static const CFieldDescriptor * const
1264  s_apFieldDescriptorTable[];
1265 
1266  static const CTypeDescriptor
1267  s_typeDescriptor;
1268 
1269  void
1270  decodeFields (
1271  CDecoderStream * pDecoderStream);
1272 
1273  void
1274  assimilateSubParameters (
1275  CErrorDetails * pError);
1276 
1277  void
1278  encode (
1279  CEncoderStream * pEncoderStream) const;
1280 
1281 
1282 
1283  static CElement *
1284  s_construct (void);
1285 
1286  static void
1287  s_decodeFields (
1288  CDecoderStream * pDecoderStream,
1289  CElement * pElement);
1291 
1292 
1293 
1294  protected:
1295  std::list<CParameter *> m_listCustom;
1296 
1297  public:
1299  inline std::list<CParameter *>::iterator
1301  {
1302  return m_listCustom.begin();
1303  }
1304 
1306  inline std::list<CParameter *>::iterator
1307  endCustom (void)
1308  {
1309  return m_listCustom.end();
1310  }
1311 
1313  inline void
1315  {
1316  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1317  }
1318 
1320  inline int
1322  {
1323  return (int) (m_listCustom.size());
1324  }
1325 
1326  EResultCode
1328  addCustom (
1329  CParameter * pValue);
1330 
1331 
1332 };
1333 
1334 
1358 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1359 {
1360  public:
1363 
1366 
1367  static const CFieldDescriptor * const
1368  s_apFieldDescriptorTable[];
1369 
1370  static const CTypeDescriptor
1371  s_typeDescriptor;
1372 
1373  void
1374  decodeFields (
1375  CDecoderStream * pDecoderStream);
1376 
1377  void
1378  assimilateSubParameters (
1379  CErrorDetails * pError);
1380 
1381  void
1382  encode (
1383  CEncoderStream * pEncoderStream) const;
1384 
1385 
1386 
1387  static CElement *
1388  s_construct (void);
1389 
1390  static void
1391  s_decodeFields (
1392  CDecoderStream * pDecoderStream,
1393  CElement * pElement);
1395 
1396 
1397 
1398  protected:
1399  CLLRPStatus * m_pLLRPStatus;
1400 
1401  public:
1403  inline CLLRPStatus *
1405  {
1406  return m_pLLRPStatus;
1407  }
1408 
1410  EResultCode
1411  setLLRPStatus (
1412  CLLRPStatus * pValue);
1413 
1414 
1415  protected:
1416  std::list<CParameter *> m_listCustom;
1417 
1418  public:
1420  inline std::list<CParameter *>::iterator
1422  {
1423  return m_listCustom.begin();
1424  }
1425 
1427  inline std::list<CParameter *>::iterator
1428  endCustom (void)
1429  {
1430  return m_listCustom.end();
1431  }
1432 
1434  inline void
1436  {
1437  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1438  }
1439 
1441  inline int
1443  {
1444  return (int) (m_listCustom.size());
1445  }
1446 
1447  EResultCode
1449  addCustom (
1450  CParameter * pValue);
1451 
1452 
1453 };
1454 
1455 
1489 class CIMPINJ_SAVE_SETTINGS : public CMessage
1490 {
1491  public:
1492  CIMPINJ_SAVE_SETTINGS (void);
1493  ~CIMPINJ_SAVE_SETTINGS (void);
1494 
1497 
1498  static const CFieldDescriptor * const
1499  s_apFieldDescriptorTable[];
1500 
1501  static const CTypeDescriptor
1502  s_typeDescriptor;
1503 
1504  void
1505  decodeFields (
1506  CDecoderStream * pDecoderStream);
1507 
1508  void
1509  assimilateSubParameters (
1510  CErrorDetails * pError);
1511 
1512  void
1513  encode (
1514  CEncoderStream * pEncoderStream) const;
1515 
1516 
1517 
1518  static CElement *
1519  s_construct (void);
1520 
1521  static void
1522  s_decodeFields (
1523  CDecoderStream * pDecoderStream,
1524  CElement * pElement);
1526 
1527 
1528  protected:
1529  llrp_u1_t m_SaveConfiguration;
1530 
1533  public:
1534  static const CFieldDescriptor
1535  s_fdSaveConfiguration;
1537 
1539  inline llrp_u1_t
1541  {
1542  return m_SaveConfiguration;
1543  }
1544 
1546  inline void
1548  llrp_u1_t value)
1549  {
1550  m_SaveConfiguration = value;
1551  }
1552 
1553 
1554 
1555  protected:
1556  std::list<CParameter *> m_listCustom;
1557 
1558  public:
1560  inline std::list<CParameter *>::iterator
1562  {
1563  return m_listCustom.begin();
1564  }
1565 
1567  inline std::list<CParameter *>::iterator
1568  endCustom (void)
1569  {
1570  return m_listCustom.end();
1571  }
1572 
1574  inline void
1576  {
1577  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1578  }
1579 
1581  inline int
1583  {
1584  return (int) (m_listCustom.size());
1585  }
1586 
1587  EResultCode
1589  addCustom (
1590  CParameter * pValue);
1591 
1592 
1593 };
1594 
1595 
1619 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1620 {
1621  public:
1624 
1627 
1628  static const CFieldDescriptor * const
1629  s_apFieldDescriptorTable[];
1630 
1631  static const CTypeDescriptor
1632  s_typeDescriptor;
1633 
1634  void
1635  decodeFields (
1636  CDecoderStream * pDecoderStream);
1637 
1638  void
1639  assimilateSubParameters (
1640  CErrorDetails * pError);
1641 
1642  void
1643  encode (
1644  CEncoderStream * pEncoderStream) const;
1645 
1646 
1647 
1648  static CElement *
1649  s_construct (void);
1650 
1651  static void
1652  s_decodeFields (
1653  CDecoderStream * pDecoderStream,
1654  CElement * pElement);
1656 
1657 
1658 
1659  protected:
1660  CLLRPStatus * m_pLLRPStatus;
1661 
1662  public:
1664  inline CLLRPStatus *
1666  {
1667  return m_pLLRPStatus;
1668  }
1669 
1671  EResultCode
1672  setLLRPStatus (
1673  CLLRPStatus * pValue);
1674 
1675 
1676  protected:
1677  std::list<CParameter *> m_listCustom;
1678 
1679  public:
1681  inline std::list<CParameter *>::iterator
1683  {
1684  return m_listCustom.begin();
1685  }
1686 
1688  inline std::list<CParameter *>::iterator
1689  endCustom (void)
1690  {
1691  return m_listCustom.end();
1692  }
1693 
1695  inline void
1697  {
1698  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1699  }
1700 
1702  inline int
1704  {
1705  return (int) (m_listCustom.size());
1706  }
1707 
1708  EResultCode
1710  addCustom (
1711  CParameter * pValue);
1712 
1713 
1714 };
1715 
1716 
1724 
1747 class CImpinjRequestedData : public CParameter
1748 {
1749  public:
1750  CImpinjRequestedData (void);
1751  ~CImpinjRequestedData (void);
1752 
1755 
1756  static const CFieldDescriptor * const
1757  s_apFieldDescriptorTable[];
1758 
1759  static const CTypeDescriptor
1760  s_typeDescriptor;
1761 
1762  void
1763  decodeFields (
1764  CDecoderStream * pDecoderStream);
1765 
1766  void
1767  assimilateSubParameters (
1768  CErrorDetails * pError);
1769 
1770  void
1771  encode (
1772  CEncoderStream * pEncoderStream) const;
1773 
1774 
1775  llrp_bool_t
1776  isAllowedIn (
1777  const CTypeDescriptor * pEnclosingElementType) const;
1778 
1779 
1780  static CElement *
1781  s_construct (void);
1782 
1783  static void
1784  s_decodeFields (
1785  CDecoderStream * pDecoderStream,
1786  CElement * pElement);
1788 
1789 
1790  protected:
1791  EImpinjRequestedDataType m_eRequestedData;
1792 
1795  public:
1796  static const CFieldDescriptor
1797  s_fdRequestedData;
1799 
1801  inline EImpinjRequestedDataType
1803  {
1804  return m_eRequestedData;
1805  }
1806 
1808  inline void
1810  EImpinjRequestedDataType value)
1811  {
1812  m_eRequestedData = value;
1813  }
1814 
1815 
1816 
1817  protected:
1818  std::list<CParameter *> m_listCustom;
1819 
1820  public:
1822  inline std::list<CParameter *>::iterator
1824  {
1825  return m_listCustom.begin();
1826  }
1827 
1829  inline std::list<CParameter *>::iterator
1830  endCustom (void)
1831  {
1832  return m_listCustom.end();
1833  }
1834 
1836  inline void
1838  {
1839  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1840  }
1841 
1843  inline int
1845  {
1846  return (int) (m_listCustom.size());
1847  }
1848 
1849  EResultCode
1851  addCustom (
1852  CParameter * pValue);
1853 
1854 
1855 };
1856 
1857 
1886 class CImpinjSubRegulatoryRegion : public CParameter
1887 {
1888  public:
1891 
1894 
1895  static const CFieldDescriptor * const
1896  s_apFieldDescriptorTable[];
1897 
1898  static const CTypeDescriptor
1899  s_typeDescriptor;
1900 
1901  void
1902  decodeFields (
1903  CDecoderStream * pDecoderStream);
1904 
1905  void
1906  assimilateSubParameters (
1907  CErrorDetails * pError);
1908 
1909  void
1910  encode (
1911  CEncoderStream * pEncoderStream) const;
1912 
1913 
1914  llrp_bool_t
1915  isAllowedIn (
1916  const CTypeDescriptor * pEnclosingElementType) const;
1917 
1918 
1919  static CElement *
1920  s_construct (void);
1921 
1922  static void
1923  s_decodeFields (
1924  CDecoderStream * pDecoderStream,
1925  CElement * pElement);
1927 
1928 
1929  protected:
1930  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1931 
1934  public:
1935  static const CFieldDescriptor
1936  s_fdRegulatoryRegion;
1938 
1940  inline EImpinjRegulatoryRegion
1942  {
1943  return m_eRegulatoryRegion;
1944  }
1945 
1947  inline void
1949  EImpinjRegulatoryRegion value)
1950  {
1951  m_eRegulatoryRegion = value;
1952  }
1953 
1954 
1955 
1956  protected:
1957  std::list<CParameter *> m_listCustom;
1958 
1959  public:
1961  inline std::list<CParameter *>::iterator
1963  {
1964  return m_listCustom.begin();
1965  }
1966 
1968  inline std::list<CParameter *>::iterator
1969  endCustom (void)
1970  {
1971  return m_listCustom.end();
1972  }
1973 
1975  inline void
1977  {
1978  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1979  }
1980 
1982  inline int
1984  {
1985  return (int) (m_listCustom.size());
1986  }
1987 
1988  EResultCode
1990  addCustom (
1991  CParameter * pValue);
1992 
1993 
1994 };
1995 
1996 
2021 class CImpinjInventorySearchMode : public CParameter
2022 {
2023  public:
2026 
2029 
2030  static const CFieldDescriptor * const
2031  s_apFieldDescriptorTable[];
2032 
2033  static const CTypeDescriptor
2034  s_typeDescriptor;
2035 
2036  void
2037  decodeFields (
2038  CDecoderStream * pDecoderStream);
2039 
2040  void
2041  assimilateSubParameters (
2042  CErrorDetails * pError);
2043 
2044  void
2045  encode (
2046  CEncoderStream * pEncoderStream) const;
2047 
2048 
2049  llrp_bool_t
2050  isAllowedIn (
2051  const CTypeDescriptor * pEnclosingElementType) const;
2052 
2053 
2054  static CElement *
2055  s_construct (void);
2056 
2057  static void
2058  s_decodeFields (
2059  CDecoderStream * pDecoderStream,
2060  CElement * pElement);
2062 
2063 
2064  protected:
2065  EImpinjInventorySearchType m_eInventorySearchMode;
2066 
2069  public:
2070  static const CFieldDescriptor
2071  s_fdInventorySearchMode;
2073 
2075  inline EImpinjInventorySearchType
2077  {
2078  return m_eInventorySearchMode;
2079  }
2080 
2082  inline void
2084  EImpinjInventorySearchType value)
2085  {
2086  m_eInventorySearchMode = value;
2087  }
2088 
2089 
2090 
2091  protected:
2092  std::list<CParameter *> m_listCustom;
2093 
2094  public:
2096  inline std::list<CParameter *>::iterator
2098  {
2099  return m_listCustom.begin();
2100  }
2101 
2103  inline std::list<CParameter *>::iterator
2104  endCustom (void)
2105  {
2106  return m_listCustom.end();
2107  }
2108 
2110  inline void
2112  {
2113  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2114  }
2115 
2117  inline int
2119  {
2120  return (int) (m_listCustom.size());
2121  }
2122 
2123  EResultCode
2125  addCustom (
2126  CParameter * pValue);
2127 
2128 
2129 };
2130 
2131 
2161 class CImpinjFixedFrequencyList : public CParameter
2162 {
2163  public:
2165  ~CImpinjFixedFrequencyList (void);
2166 
2169 
2170  static const CFieldDescriptor * const
2171  s_apFieldDescriptorTable[];
2172 
2173  static const CTypeDescriptor
2174  s_typeDescriptor;
2175 
2176  void
2177  decodeFields (
2178  CDecoderStream * pDecoderStream);
2179 
2180  void
2181  assimilateSubParameters (
2182  CErrorDetails * pError);
2183 
2184  void
2185  encode (
2186  CEncoderStream * pEncoderStream) const;
2187 
2188 
2189  llrp_bool_t
2190  isAllowedIn (
2191  const CTypeDescriptor * pEnclosingElementType) const;
2192 
2193 
2194  static CElement *
2195  s_construct (void);
2196 
2197  static void
2198  s_decodeFields (
2199  CDecoderStream * pDecoderStream,
2200  CElement * pElement);
2202 
2203 
2204  protected:
2205  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
2206 
2209  public:
2210  static const CFieldDescriptor
2211  s_fdFixedFrequencyMode;
2213 
2215  inline EImpinjFixedFrequencyMode
2217  {
2218  return m_eFixedFrequencyMode;
2219  }
2220 
2222  inline void
2224  EImpinjFixedFrequencyMode value)
2225  {
2226  m_eFixedFrequencyMode = value;
2227  }
2228 
2229 
2230  protected:
2231  llrp_u16v_t m_ChannelList;
2232 
2235  public:
2236  static const CFieldDescriptor
2237  s_fdChannelList;
2239 
2241  inline llrp_u16v_t
2243  {
2244  return m_ChannelList;
2245  }
2246 
2248  inline void
2250  llrp_u16v_t value)
2251  {
2252  m_ChannelList = value;
2253  }
2254 
2255 
2256 
2257  protected:
2258  std::list<CParameter *> m_listCustom;
2259 
2260  public:
2262  inline std::list<CParameter *>::iterator
2264  {
2265  return m_listCustom.begin();
2266  }
2267 
2269  inline std::list<CParameter *>::iterator
2270  endCustom (void)
2271  {
2272  return m_listCustom.end();
2273  }
2274 
2276  inline void
2278  {
2279  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2280  }
2281 
2283  inline int
2285  {
2286  return (int) (m_listCustom.size());
2287  }
2288 
2289  EResultCode
2291  addCustom (
2292  CParameter * pValue);
2293 
2294 
2295 };
2296 
2297 
2327 class CImpinjReducedPowerFrequencyList : public CParameter
2328 {
2329  public:
2332 
2335 
2336  static const CFieldDescriptor * const
2337  s_apFieldDescriptorTable[];
2338 
2339  static const CTypeDescriptor
2340  s_typeDescriptor;
2341 
2342  void
2343  decodeFields (
2344  CDecoderStream * pDecoderStream);
2345 
2346  void
2347  assimilateSubParameters (
2348  CErrorDetails * pError);
2349 
2350  void
2351  encode (
2352  CEncoderStream * pEncoderStream) const;
2353 
2354 
2355  llrp_bool_t
2356  isAllowedIn (
2357  const CTypeDescriptor * pEnclosingElementType) const;
2358 
2359 
2360  static CElement *
2361  s_construct (void);
2362 
2363  static void
2364  s_decodeFields (
2365  CDecoderStream * pDecoderStream,
2366  CElement * pElement);
2368 
2369 
2370  protected:
2371  EImpinjReducedPowerMode m_eReducedPowerMode;
2372 
2375  public:
2376  static const CFieldDescriptor
2377  s_fdReducedPowerMode;
2379 
2381  inline EImpinjReducedPowerMode
2383  {
2384  return m_eReducedPowerMode;
2385  }
2386 
2388  inline void
2390  EImpinjReducedPowerMode value)
2391  {
2392  m_eReducedPowerMode = value;
2393  }
2394 
2395 
2396  protected:
2397  llrp_u16v_t m_ChannelList;
2398 
2401  public:
2402  static const CFieldDescriptor
2403  s_fdChannelList;
2405 
2407  inline llrp_u16v_t
2409  {
2410  return m_ChannelList;
2411  }
2412 
2414  inline void
2416  llrp_u16v_t value)
2417  {
2418  m_ChannelList = value;
2419  }
2420 
2421 
2422 
2423  protected:
2424  std::list<CParameter *> m_listCustom;
2425 
2426  public:
2428  inline std::list<CParameter *>::iterator
2430  {
2431  return m_listCustom.begin();
2432  }
2433 
2435  inline std::list<CParameter *>::iterator
2436  endCustom (void)
2437  {
2438  return m_listCustom.end();
2439  }
2440 
2442  inline void
2444  {
2445  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2446  }
2447 
2449  inline int
2451  {
2452  return (int) (m_listCustom.size());
2453  }
2454 
2455  EResultCode
2457  addCustom (
2458  CParameter * pValue);
2459 
2460 
2461 };
2462 
2463 
2493 class CImpinjLowDutyCycle : public CParameter
2494 {
2495  public:
2496  CImpinjLowDutyCycle (void);
2497  ~CImpinjLowDutyCycle (void);
2498 
2501 
2502  static const CFieldDescriptor * const
2503  s_apFieldDescriptorTable[];
2504 
2505  static const CTypeDescriptor
2506  s_typeDescriptor;
2507 
2508  void
2509  decodeFields (
2510  CDecoderStream * pDecoderStream);
2511 
2512  void
2513  assimilateSubParameters (
2514  CErrorDetails * pError);
2515 
2516  void
2517  encode (
2518  CEncoderStream * pEncoderStream) const;
2519 
2520 
2521  llrp_bool_t
2522  isAllowedIn (
2523  const CTypeDescriptor * pEnclosingElementType) const;
2524 
2525 
2526  static CElement *
2527  s_construct (void);
2528 
2529  static void
2530  s_decodeFields (
2531  CDecoderStream * pDecoderStream,
2532  CElement * pElement);
2534 
2535 
2536  protected:
2537  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2538 
2541  public:
2542  static const CFieldDescriptor
2543  s_fdLowDutyCycleMode;
2545 
2547  inline EImpinjLowDutyCycleMode
2549  {
2550  return m_eLowDutyCycleMode;
2551  }
2552 
2554  inline void
2556  EImpinjLowDutyCycleMode value)
2557  {
2558  m_eLowDutyCycleMode = value;
2559  }
2560 
2561 
2562  protected:
2563  llrp_u16_t m_EmptyFieldTimeout;
2564 
2567  public:
2568  static const CFieldDescriptor
2569  s_fdEmptyFieldTimeout;
2571 
2573  inline llrp_u16_t
2575  {
2576  return m_EmptyFieldTimeout;
2577  }
2578 
2580  inline void
2582  llrp_u16_t value)
2583  {
2584  m_EmptyFieldTimeout = value;
2585  }
2586 
2587 
2588  protected:
2589  llrp_u16_t m_FieldPingInterval;
2590 
2593  public:
2594  static const CFieldDescriptor
2595  s_fdFieldPingInterval;
2597 
2599  inline llrp_u16_t
2601  {
2602  return m_FieldPingInterval;
2603  }
2604 
2606  inline void
2608  llrp_u16_t value)
2609  {
2610  m_FieldPingInterval = value;
2611  }
2612 
2613 
2614 
2615  protected:
2616  std::list<CParameter *> m_listCustom;
2617 
2618  public:
2620  inline std::list<CParameter *>::iterator
2622  {
2623  return m_listCustom.begin();
2624  }
2625 
2627  inline std::list<CParameter *>::iterator
2628  endCustom (void)
2629  {
2630  return m_listCustom.end();
2631  }
2632 
2634  inline void
2636  {
2637  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2638  }
2639 
2641  inline int
2643  {
2644  return (int) (m_listCustom.size());
2645  }
2646 
2647  EResultCode
2649  addCustom (
2650  CParameter * pValue);
2651 
2652 
2653 };
2654 
2655 
2680 class CImpinjHubVersions : public CParameter
2681 {
2682  public:
2683  CImpinjHubVersions (void);
2684  ~CImpinjHubVersions (void);
2685 
2688 
2689  static const CFieldDescriptor * const
2690  s_apFieldDescriptorTable[];
2691 
2692  static const CTypeDescriptor
2693  s_typeDescriptor;
2694 
2695  void
2696  decodeFields (
2697  CDecoderStream * pDecoderStream);
2698 
2699  void
2700  assimilateSubParameters (
2701  CErrorDetails * pError);
2702 
2703  void
2704  encode (
2705  CEncoderStream * pEncoderStream) const;
2706 
2707 
2708  llrp_bool_t
2709  isAllowedIn (
2710  const CTypeDescriptor * pEnclosingElementType) const;
2711 
2712 
2713  static CElement *
2714  s_construct (void);
2715 
2716  static void
2717  s_decodeFields (
2718  CDecoderStream * pDecoderStream,
2719  CElement * pElement);
2721 
2722 
2723 
2724  protected:
2725  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2726 
2727  public:
2729  inline std::list<CImpinjArrayVersion *>::iterator
2731  {
2732  return m_listImpinjArrayVersion.begin();
2733  }
2734 
2736  inline std::list<CImpinjArrayVersion *>::iterator
2738  {
2739  return m_listImpinjArrayVersion.end();
2740  }
2741 
2743  inline void
2745  {
2746  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2747  }
2748 
2750  inline int
2752  {
2753  return (int) (m_listImpinjArrayVersion.size());
2754  }
2755 
2756  EResultCode
2758  addImpinjArrayVersion (
2759  CImpinjArrayVersion * pValue);
2760 
2761 
2762  protected:
2763  std::list<CParameter *> m_listCustom;
2764 
2765  public:
2767  inline std::list<CParameter *>::iterator
2769  {
2770  return m_listCustom.begin();
2771  }
2772 
2774  inline std::list<CParameter *>::iterator
2775  endCustom (void)
2776  {
2777  return m_listCustom.end();
2778  }
2779 
2781  inline void
2783  {
2784  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2785  }
2786 
2788  inline int
2790  {
2791  return (int) (m_listCustom.size());
2792  }
2793 
2794  EResultCode
2796  addCustom (
2797  CParameter * pValue);
2798 
2799 
2800 };
2801 
2802 
2835 class CImpinjDetailedVersion : public CParameter
2836 {
2837  public:
2838  CImpinjDetailedVersion (void);
2839  ~CImpinjDetailedVersion (void);
2840 
2843 
2844  static const CFieldDescriptor * const
2845  s_apFieldDescriptorTable[];
2846 
2847  static const CTypeDescriptor
2848  s_typeDescriptor;
2849 
2850  void
2851  decodeFields (
2852  CDecoderStream * pDecoderStream);
2853 
2854  void
2855  assimilateSubParameters (
2856  CErrorDetails * pError);
2857 
2858  void
2859  encode (
2860  CEncoderStream * pEncoderStream) const;
2861 
2862 
2863  llrp_bool_t
2864  isAllowedIn (
2865  const CTypeDescriptor * pEnclosingElementType) const;
2866 
2867 
2868  static CElement *
2869  s_construct (void);
2870 
2871  static void
2872  s_decodeFields (
2873  CDecoderStream * pDecoderStream,
2874  CElement * pElement);
2876 
2877 
2878  protected:
2879  llrp_utf8v_t m_ModelName;
2880 
2883  public:
2884  static const CFieldDescriptor
2885  s_fdModelName;
2887 
2889  inline llrp_utf8v_t
2891  {
2892  return m_ModelName;
2893  }
2894 
2896  inline void
2898  llrp_utf8v_t value)
2899  {
2900  m_ModelName = value;
2901  }
2902 
2903 
2904  protected:
2905  llrp_utf8v_t m_SerialNumber;
2906 
2909  public:
2910  static const CFieldDescriptor
2911  s_fdSerialNumber;
2913 
2915  inline llrp_utf8v_t
2917  {
2918  return m_SerialNumber;
2919  }
2920 
2922  inline void
2924  llrp_utf8v_t value)
2925  {
2926  m_SerialNumber = value;
2927  }
2928 
2929 
2930  protected:
2931  llrp_utf8v_t m_SoftwareVersion;
2932 
2935  public:
2936  static const CFieldDescriptor
2937  s_fdSoftwareVersion;
2939 
2941  inline llrp_utf8v_t
2943  {
2944  return m_SoftwareVersion;
2945  }
2946 
2948  inline void
2950  llrp_utf8v_t value)
2951  {
2952  m_SoftwareVersion = value;
2953  }
2954 
2955 
2956  protected:
2957  llrp_utf8v_t m_FirmwareVersion;
2958 
2961  public:
2962  static const CFieldDescriptor
2963  s_fdFirmwareVersion;
2965 
2967  inline llrp_utf8v_t
2969  {
2970  return m_FirmwareVersion;
2971  }
2972 
2974  inline void
2976  llrp_utf8v_t value)
2977  {
2978  m_FirmwareVersion = value;
2979  }
2980 
2981 
2982  protected:
2983  llrp_utf8v_t m_FPGAVersion;
2984 
2987  public:
2988  static const CFieldDescriptor
2989  s_fdFPGAVersion;
2991 
2993  inline llrp_utf8v_t
2995  {
2996  return m_FPGAVersion;
2997  }
2998 
3000  inline void
3002  llrp_utf8v_t value)
3003  {
3004  m_FPGAVersion = value;
3005  }
3006 
3007 
3008  protected:
3009  llrp_utf8v_t m_PCBAVersion;
3010 
3013  public:
3014  static const CFieldDescriptor
3015  s_fdPCBAVersion;
3017 
3019  inline llrp_utf8v_t
3021  {
3022  return m_PCBAVersion;
3023  }
3024 
3026  inline void
3028  llrp_utf8v_t value)
3029  {
3030  m_PCBAVersion = value;
3031  }
3032 
3033 
3034 
3035  protected:
3036  CImpinjHubVersions * m_pImpinjHubVersions;
3037 
3038  public:
3040  inline CImpinjHubVersions *
3042  {
3043  return m_pImpinjHubVersions;
3044  }
3045 
3047  EResultCode
3048  setImpinjHubVersions (
3049  CImpinjHubVersions * pValue);
3050 
3051 
3052  protected:
3053  CImpinjArrayVersion * m_pImpinjArrayVersion;
3054 
3055  public:
3057  inline CImpinjArrayVersion *
3059  {
3060  return m_pImpinjArrayVersion;
3061  }
3062 
3064  EResultCode
3065  setImpinjArrayVersion (
3066  CImpinjArrayVersion * pValue);
3067 
3068 
3069  protected:
3070  CImpinjBLEVersion * m_pImpinjBLEVersion;
3071 
3072  public:
3074  inline CImpinjBLEVersion *
3076  {
3077  return m_pImpinjBLEVersion;
3078  }
3079 
3081  EResultCode
3082  setImpinjBLEVersion (
3083  CImpinjBLEVersion * pValue);
3084 
3085 
3086  protected:
3087  std::list<CParameter *> m_listCustom;
3088 
3089  public:
3091  inline std::list<CParameter *>::iterator
3093  {
3094  return m_listCustom.begin();
3095  }
3096 
3098  inline std::list<CParameter *>::iterator
3099  endCustom (void)
3100  {
3101  return m_listCustom.end();
3102  }
3103 
3105  inline void
3107  {
3108  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3109  }
3110 
3112  inline int
3114  {
3115  return (int) (m_listCustom.size());
3116  }
3117 
3118  EResultCode
3120  addCustom (
3121  CParameter * pValue);
3122 
3123 
3124 };
3125 
3126 
3151 class CImpinjFrequencyCapabilities : public CParameter
3152 {
3153  public:
3156 
3159 
3160  static const CFieldDescriptor * const
3161  s_apFieldDescriptorTable[];
3162 
3163  static const CTypeDescriptor
3164  s_typeDescriptor;
3165 
3166  void
3167  decodeFields (
3168  CDecoderStream * pDecoderStream);
3169 
3170  void
3171  assimilateSubParameters (
3172  CErrorDetails * pError);
3173 
3174  void
3175  encode (
3176  CEncoderStream * pEncoderStream) const;
3177 
3178 
3179  llrp_bool_t
3180  isAllowedIn (
3181  const CTypeDescriptor * pEnclosingElementType) const;
3182 
3183 
3184  static CElement *
3185  s_construct (void);
3186 
3187  static void
3188  s_decodeFields (
3189  CDecoderStream * pDecoderStream,
3190  CElement * pElement);
3192 
3193 
3194  protected:
3195  llrp_u32v_t m_FrequencyList;
3196 
3199  public:
3200  static const CFieldDescriptor
3201  s_fdFrequencyList;
3203 
3205  inline llrp_u32v_t
3207  {
3208  return m_FrequencyList;
3209  }
3210 
3212  inline void
3214  llrp_u32v_t value)
3215  {
3216  m_FrequencyList = value;
3217  }
3218 
3219 
3220 
3221  protected:
3222  std::list<CParameter *> m_listCustom;
3223 
3224  public:
3226  inline std::list<CParameter *>::iterator
3228  {
3229  return m_listCustom.begin();
3230  }
3231 
3233  inline std::list<CParameter *>::iterator
3234  endCustom (void)
3235  {
3236  return m_listCustom.end();
3237  }
3238 
3240  inline void
3242  {
3243  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3244  }
3245 
3247  inline int
3249  {
3250  return (int) (m_listCustom.size());
3251  }
3252 
3253  EResultCode
3255  addCustom (
3256  CParameter * pValue);
3257 
3258 
3259 };
3260 
3261 
3288 class CImpinjGPIDebounceConfiguration : public CParameter
3289 {
3290  public:
3293 
3296 
3297  static const CFieldDescriptor * const
3298  s_apFieldDescriptorTable[];
3299 
3300  static const CTypeDescriptor
3301  s_typeDescriptor;
3302 
3303  void
3304  decodeFields (
3305  CDecoderStream * pDecoderStream);
3306 
3307  void
3308  assimilateSubParameters (
3309  CErrorDetails * pError);
3310 
3311  void
3312  encode (
3313  CEncoderStream * pEncoderStream) const;
3314 
3315 
3316  llrp_bool_t
3317  isAllowedIn (
3318  const CTypeDescriptor * pEnclosingElementType) const;
3319 
3320 
3321  static CElement *
3322  s_construct (void);
3323 
3324  static void
3325  s_decodeFields (
3326  CDecoderStream * pDecoderStream,
3327  CElement * pElement);
3329 
3330 
3331  protected:
3332  llrp_u16_t m_GPIPortNum;
3333 
3336  public:
3337  static const CFieldDescriptor
3338  s_fdGPIPortNum;
3340 
3342  inline llrp_u16_t
3344  {
3345  return m_GPIPortNum;
3346  }
3347 
3349  inline void
3351  llrp_u16_t value)
3352  {
3353  m_GPIPortNum = value;
3354  }
3355 
3356 
3357  protected:
3358  llrp_u32_t m_GPIDebounceTimerMSec;
3359 
3362  public:
3363  static const CFieldDescriptor
3364  s_fdGPIDebounceTimerMSec;
3366 
3368  inline llrp_u32_t
3370  {
3371  return m_GPIDebounceTimerMSec;
3372  }
3373 
3375  inline void
3377  llrp_u32_t value)
3378  {
3379  m_GPIDebounceTimerMSec = value;
3380  }
3381 
3382 
3383 
3384  protected:
3385  std::list<CParameter *> m_listCustom;
3386 
3387  public:
3389  inline std::list<CParameter *>::iterator
3391  {
3392  return m_listCustom.begin();
3393  }
3394 
3396  inline std::list<CParameter *>::iterator
3397  endCustom (void)
3398  {
3399  return m_listCustom.end();
3400  }
3401 
3403  inline void
3405  {
3406  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3407  }
3408 
3410  inline int
3412  {
3413  return (int) (m_listCustom.size());
3414  }
3415 
3416  EResultCode
3418  addCustom (
3419  CParameter * pValue);
3420 
3421 
3422 };
3423 
3424 
3449 class CImpinjReaderTemperature : public CParameter
3450 {
3451  public:
3452  CImpinjReaderTemperature (void);
3453  ~CImpinjReaderTemperature (void);
3454 
3457 
3458  static const CFieldDescriptor * const
3459  s_apFieldDescriptorTable[];
3460 
3461  static const CTypeDescriptor
3462  s_typeDescriptor;
3463 
3464  void
3465  decodeFields (
3466  CDecoderStream * pDecoderStream);
3467 
3468  void
3469  assimilateSubParameters (
3470  CErrorDetails * pError);
3471 
3472  void
3473  encode (
3474  CEncoderStream * pEncoderStream) const;
3475 
3476 
3477  llrp_bool_t
3478  isAllowedIn (
3479  const CTypeDescriptor * pEnclosingElementType) const;
3480 
3481 
3482  static CElement *
3483  s_construct (void);
3484 
3485  static void
3486  s_decodeFields (
3487  CDecoderStream * pDecoderStream,
3488  CElement * pElement);
3490 
3491 
3492  protected:
3493  llrp_s16_t m_Temperature;
3494 
3497  public:
3498  static const CFieldDescriptor
3499  s_fdTemperature;
3501 
3503  inline llrp_s16_t
3505  {
3506  return m_Temperature;
3507  }
3508 
3510  inline void
3512  llrp_s16_t value)
3513  {
3514  m_Temperature = value;
3515  }
3516 
3517 
3518 
3519  protected:
3520  std::list<CParameter *> m_listCustom;
3521 
3522  public:
3524  inline std::list<CParameter *>::iterator
3526  {
3527  return m_listCustom.begin();
3528  }
3529 
3531  inline std::list<CParameter *>::iterator
3532  endCustom (void)
3533  {
3534  return m_listCustom.end();
3535  }
3536 
3538  inline void
3540  {
3541  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3542  }
3543 
3545  inline int
3547  {
3548  return (int) (m_listCustom.size());
3549  }
3550 
3551  EResultCode
3553  addCustom (
3554  CParameter * pValue);
3555 
3556 
3557 };
3558 
3559 
3586 class CImpinjLinkMonitorConfiguration : public CParameter
3587 {
3588  public:
3591 
3594 
3595  static const CFieldDescriptor * const
3596  s_apFieldDescriptorTable[];
3597 
3598  static const CTypeDescriptor
3599  s_typeDescriptor;
3600 
3601  void
3602  decodeFields (
3603  CDecoderStream * pDecoderStream);
3604 
3605  void
3606  assimilateSubParameters (
3607  CErrorDetails * pError);
3608 
3609  void
3610  encode (
3611  CEncoderStream * pEncoderStream) const;
3612 
3613 
3614  llrp_bool_t
3615  isAllowedIn (
3616  const CTypeDescriptor * pEnclosingElementType) const;
3617 
3618 
3619  static CElement *
3620  s_construct (void);
3621 
3622  static void
3623  s_decodeFields (
3624  CDecoderStream * pDecoderStream,
3625  CElement * pElement);
3627 
3628 
3629  protected:
3630  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3631 
3634  public:
3635  static const CFieldDescriptor
3636  s_fdLinkMonitorMode;
3638 
3640  inline EImpinjLinkMonitorMode
3642  {
3643  return m_eLinkMonitorMode;
3644  }
3645 
3647  inline void
3649  EImpinjLinkMonitorMode value)
3650  {
3651  m_eLinkMonitorMode = value;
3652  }
3653 
3654 
3655  protected:
3656  llrp_u16_t m_LinkDownThreshold;
3657 
3660  public:
3661  static const CFieldDescriptor
3662  s_fdLinkDownThreshold;
3664 
3666  inline llrp_u16_t
3668  {
3669  return m_LinkDownThreshold;
3670  }
3671 
3673  inline void
3675  llrp_u16_t value)
3676  {
3677  m_LinkDownThreshold = value;
3678  }
3679 
3680 
3681 
3682  protected:
3683  std::list<CParameter *> m_listCustom;
3684 
3685  public:
3687  inline std::list<CParameter *>::iterator
3689  {
3690  return m_listCustom.begin();
3691  }
3692 
3694  inline std::list<CParameter *>::iterator
3695  endCustom (void)
3696  {
3697  return m_listCustom.end();
3698  }
3699 
3701  inline void
3703  {
3704  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3705  }
3706 
3708  inline int
3710  {
3711  return (int) (m_listCustom.size());
3712  }
3713 
3714  EResultCode
3716  addCustom (
3717  CParameter * pValue);
3718 
3719 
3720 };
3721 
3722 
3748 class CImpinjReportBufferConfiguration : public CParameter
3749 {
3750  public:
3753 
3756 
3757  static const CFieldDescriptor * const
3758  s_apFieldDescriptorTable[];
3759 
3760  static const CTypeDescriptor
3761  s_typeDescriptor;
3762 
3763  void
3764  decodeFields (
3765  CDecoderStream * pDecoderStream);
3766 
3767  void
3768  assimilateSubParameters (
3769  CErrorDetails * pError);
3770 
3771  void
3772  encode (
3773  CEncoderStream * pEncoderStream) const;
3774 
3775 
3776  llrp_bool_t
3777  isAllowedIn (
3778  const CTypeDescriptor * pEnclosingElementType) const;
3779 
3780 
3781  static CElement *
3782  s_construct (void);
3783 
3784  static void
3785  s_decodeFields (
3786  CDecoderStream * pDecoderStream,
3787  CElement * pElement);
3789 
3790 
3791  protected:
3792  EImpinjReportBufferMode m_eReportBufferMode;
3793 
3796  public:
3797  static const CFieldDescriptor
3798  s_fdReportBufferMode;
3800 
3802  inline EImpinjReportBufferMode
3804  {
3805  return m_eReportBufferMode;
3806  }
3807 
3809  inline void
3811  EImpinjReportBufferMode value)
3812  {
3813  m_eReportBufferMode = value;
3814  }
3815 
3816 
3817 
3818  protected:
3819  std::list<CParameter *> m_listCustom;
3820 
3821  public:
3823  inline std::list<CParameter *>::iterator
3825  {
3826  return m_listCustom.begin();
3827  }
3828 
3830  inline std::list<CParameter *>::iterator
3831  endCustom (void)
3832  {
3833  return m_listCustom.end();
3834  }
3835 
3837  inline void
3839  {
3840  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3841  }
3842 
3844  inline int
3846  {
3847  return (int) (m_listCustom.size());
3848  }
3849 
3850  EResultCode
3852  addCustom (
3853  CParameter * pValue);
3854 
3855 
3856 };
3857 
3858 
3887 class CImpinjAccessSpecConfiguration : public CParameter
3888 {
3889  public:
3892 
3895 
3896  static const CFieldDescriptor * const
3897  s_apFieldDescriptorTable[];
3898 
3899  static const CTypeDescriptor
3900  s_typeDescriptor;
3901 
3902  void
3903  decodeFields (
3904  CDecoderStream * pDecoderStream);
3905 
3906  void
3907  assimilateSubParameters (
3908  CErrorDetails * pError);
3909 
3910  void
3911  encode (
3912  CEncoderStream * pEncoderStream) const;
3913 
3914 
3915  llrp_bool_t
3916  isAllowedIn (
3917  const CTypeDescriptor * pEnclosingElementType) const;
3918 
3919 
3920  static CElement *
3921  s_construct (void);
3922 
3923  static void
3924  s_decodeFields (
3925  CDecoderStream * pDecoderStream,
3926  CElement * pElement);
3928 
3929 
3930 
3931  protected:
3932  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3933 
3934  public:
3938  {
3939  return m_pImpinjBlockWriteWordCount;
3940  }
3941 
3943  EResultCode
3944  setImpinjBlockWriteWordCount (
3945  CImpinjBlockWriteWordCount * pValue);
3946 
3947 
3948  protected:
3949  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3950 
3951  public:
3953  inline CImpinjOpSpecRetryCount *
3955  {
3956  return m_pImpinjOpSpecRetryCount;
3957  }
3958 
3960  EResultCode
3961  setImpinjOpSpecRetryCount (
3962  CImpinjOpSpecRetryCount * pValue);
3963 
3964 
3965  protected:
3966  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3967 
3968  public:
3970  inline CImpinjAccessSpecOrdering *
3972  {
3973  return m_pImpinjAccessSpecOrdering;
3974  }
3975 
3977  EResultCode
3978  setImpinjAccessSpecOrdering (
3979  CImpinjAccessSpecOrdering * pValue);
3980 
3981 
3982  protected:
3983  std::list<CParameter *> m_listCustom;
3984 
3985  public:
3987  inline std::list<CParameter *>::iterator
3989  {
3990  return m_listCustom.begin();
3991  }
3992 
3994  inline std::list<CParameter *>::iterator
3995  endCustom (void)
3996  {
3997  return m_listCustom.end();
3998  }
3999 
4001  inline void
4003  {
4004  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4005  }
4006 
4008  inline int
4010  {
4011  return (int) (m_listCustom.size());
4012  }
4013 
4014  EResultCode
4016  addCustom (
4017  CParameter * pValue);
4018 
4019 
4020 };
4021 
4022 
4046 class CImpinjBlockWriteWordCount : public CParameter
4047 {
4048  public:
4051 
4054 
4055  static const CFieldDescriptor * const
4056  s_apFieldDescriptorTable[];
4057 
4058  static const CTypeDescriptor
4059  s_typeDescriptor;
4060 
4061  void
4062  decodeFields (
4063  CDecoderStream * pDecoderStream);
4064 
4065  void
4066  assimilateSubParameters (
4067  CErrorDetails * pError);
4068 
4069  void
4070  encode (
4071  CEncoderStream * pEncoderStream) const;
4072 
4073 
4074  llrp_bool_t
4075  isAllowedIn (
4076  const CTypeDescriptor * pEnclosingElementType) const;
4077 
4078 
4079  static CElement *
4080  s_construct (void);
4081 
4082  static void
4083  s_decodeFields (
4084  CDecoderStream * pDecoderStream,
4085  CElement * pElement);
4087 
4088 
4089  protected:
4090  llrp_u16_t m_WordCount;
4091 
4094  public:
4095  static const CFieldDescriptor
4096  s_fdWordCount;
4098 
4100  inline llrp_u16_t
4102  {
4103  return m_WordCount;
4104  }
4105 
4107  inline void
4109  llrp_u16_t value)
4110  {
4111  m_WordCount = value;
4112  }
4113 
4114 
4115 
4116  protected:
4117  std::list<CParameter *> m_listCustom;
4118 
4119  public:
4121  inline std::list<CParameter *>::iterator
4123  {
4124  return m_listCustom.begin();
4125  }
4126 
4128  inline std::list<CParameter *>::iterator
4129  endCustom (void)
4130  {
4131  return m_listCustom.end();
4132  }
4133 
4135  inline void
4137  {
4138  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4139  }
4140 
4142  inline int
4144  {
4145  return (int) (m_listCustom.size());
4146  }
4147 
4148  EResultCode
4150  addCustom (
4151  CParameter * pValue);
4152 
4153 
4154 };
4155 
4156 
4186 class CImpinjBlockPermalock : public CParameter
4187 {
4188  public:
4189  CImpinjBlockPermalock (void);
4190  ~CImpinjBlockPermalock (void);
4191 
4194 
4195  static const CFieldDescriptor * const
4196  s_apFieldDescriptorTable[];
4197 
4198  static const CTypeDescriptor
4199  s_typeDescriptor;
4200 
4201  void
4202  decodeFields (
4203  CDecoderStream * pDecoderStream);
4204 
4205  void
4206  assimilateSubParameters (
4207  CErrorDetails * pError);
4208 
4209  void
4210  encode (
4211  CEncoderStream * pEncoderStream) const;
4212 
4213 
4214  llrp_bool_t
4215  isAllowedIn (
4216  const CTypeDescriptor * pEnclosingElementType) const;
4217 
4218 
4219  static CElement *
4220  s_construct (void);
4221 
4222  static void
4223  s_decodeFields (
4224  CDecoderStream * pDecoderStream,
4225  CElement * pElement);
4227 
4228 
4229  protected:
4230  llrp_u16_t m_OpSpecID;
4231 
4234  public:
4235  static const CFieldDescriptor
4236  s_fdOpSpecID;
4238 
4240  inline llrp_u16_t
4242  {
4243  return m_OpSpecID;
4244  }
4245 
4247  inline void
4249  llrp_u16_t value)
4250  {
4251  m_OpSpecID = value;
4252  }
4253 
4254 
4255  protected:
4256  llrp_u32_t m_AccessPassword;
4257 
4260  public:
4261  static const CFieldDescriptor
4262  s_fdAccessPassword;
4264 
4266  inline llrp_u32_t
4268  {
4269  return m_AccessPassword;
4270  }
4271 
4273  inline void
4275  llrp_u32_t value)
4276  {
4277  m_AccessPassword = value;
4278  }
4279 
4280 
4281  protected:
4282  llrp_u2_t m_MB;
4283 
4286  public:
4287  static const CFieldDescriptor
4288  s_fdMB;
4290 
4292  inline llrp_u2_t
4293  getMB (void)
4294  {
4295  return m_MB;
4296  }
4297 
4299  inline void
4301  llrp_u2_t value)
4302  {
4303  m_MB = value;
4304  }
4305 
4306 
4307  protected:
4308  llrp_u16_t m_BlockPointer;
4309 
4312  public:
4313  static const CFieldDescriptor
4314  s_fdBlockPointer;
4316 
4318  inline llrp_u16_t
4320  {
4321  return m_BlockPointer;
4322  }
4323 
4325  inline void
4327  llrp_u16_t value)
4328  {
4329  m_BlockPointer = value;
4330  }
4331 
4332 
4333  protected:
4334  llrp_u16v_t m_BlockMask;
4335 
4338  public:
4339  static const CFieldDescriptor
4340  s_fdBlockMask;
4342 
4344  inline llrp_u16v_t
4346  {
4347  return m_BlockMask;
4348  }
4349 
4351  inline void
4353  llrp_u16v_t value)
4354  {
4355  m_BlockMask = value;
4356  }
4357 
4358 
4359 
4360  protected:
4361  std::list<CParameter *> m_listCustom;
4362 
4363  public:
4365  inline std::list<CParameter *>::iterator
4367  {
4368  return m_listCustom.begin();
4369  }
4370 
4372  inline std::list<CParameter *>::iterator
4373  endCustom (void)
4374  {
4375  return m_listCustom.end();
4376  }
4377 
4379  inline void
4381  {
4382  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4383  }
4384 
4386  inline int
4388  {
4389  return (int) (m_listCustom.size());
4390  }
4391 
4392  EResultCode
4394  addCustom (
4395  CParameter * pValue);
4396 
4397 
4398 };
4399 
4400 
4426 class CImpinjBlockPermalockOpSpecResult : public CParameter
4427 {
4428  public:
4431 
4434 
4435  static const CFieldDescriptor * const
4436  s_apFieldDescriptorTable[];
4437 
4438  static const CTypeDescriptor
4439  s_typeDescriptor;
4440 
4441  void
4442  decodeFields (
4443  CDecoderStream * pDecoderStream);
4444 
4445  void
4446  assimilateSubParameters (
4447  CErrorDetails * pError);
4448 
4449  void
4450  encode (
4451  CEncoderStream * pEncoderStream) const;
4452 
4453 
4454  llrp_bool_t
4455  isAllowedIn (
4456  const CTypeDescriptor * pEnclosingElementType) const;
4457 
4458 
4459  static CElement *
4460  s_construct (void);
4461 
4462  static void
4463  s_decodeFields (
4464  CDecoderStream * pDecoderStream,
4465  CElement * pElement);
4467 
4468 
4469  protected:
4470  EImpinjBlockPermalockResultType m_eResult;
4471 
4474  public:
4475  static const CFieldDescriptor
4476  s_fdResult;
4478 
4480  inline EImpinjBlockPermalockResultType
4481  getResult (void)
4482  {
4483  return m_eResult;
4484  }
4485 
4487  inline void
4489  EImpinjBlockPermalockResultType value)
4490  {
4491  m_eResult = value;
4492  }
4493 
4494 
4495  protected:
4496  llrp_u16_t m_OpSpecID;
4497 
4500  public:
4501  static const CFieldDescriptor
4502  s_fdOpSpecID;
4504 
4506  inline llrp_u16_t
4508  {
4509  return m_OpSpecID;
4510  }
4511 
4513  inline void
4515  llrp_u16_t value)
4516  {
4517  m_OpSpecID = value;
4518  }
4519 
4520 
4521 
4522  protected:
4523  std::list<CParameter *> m_listCustom;
4524 
4525  public:
4527  inline std::list<CParameter *>::iterator
4529  {
4530  return m_listCustom.begin();
4531  }
4532 
4534  inline std::list<CParameter *>::iterator
4535  endCustom (void)
4536  {
4537  return m_listCustom.end();
4538  }
4539 
4541  inline void
4543  {
4544  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4545  }
4546 
4548  inline int
4550  {
4551  return (int) (m_listCustom.size());
4552  }
4553 
4554  EResultCode
4556  addCustom (
4557  CParameter * pValue);
4558 
4559 
4560 };
4561 
4562 
4592 class CImpinjGetBlockPermalockStatus : public CParameter
4593 {
4594  public:
4597 
4600 
4601  static const CFieldDescriptor * const
4602  s_apFieldDescriptorTable[];
4603 
4604  static const CTypeDescriptor
4605  s_typeDescriptor;
4606 
4607  void
4608  decodeFields (
4609  CDecoderStream * pDecoderStream);
4610 
4611  void
4612  assimilateSubParameters (
4613  CErrorDetails * pError);
4614 
4615  void
4616  encode (
4617  CEncoderStream * pEncoderStream) const;
4618 
4619 
4620  llrp_bool_t
4621  isAllowedIn (
4622  const CTypeDescriptor * pEnclosingElementType) const;
4623 
4624 
4625  static CElement *
4626  s_construct (void);
4627 
4628  static void
4629  s_decodeFields (
4630  CDecoderStream * pDecoderStream,
4631  CElement * pElement);
4633 
4634 
4635  protected:
4636  llrp_u16_t m_OpSpecID;
4637 
4640  public:
4641  static const CFieldDescriptor
4642  s_fdOpSpecID;
4644 
4646  inline llrp_u16_t
4648  {
4649  return m_OpSpecID;
4650  }
4651 
4653  inline void
4655  llrp_u16_t value)
4656  {
4657  m_OpSpecID = value;
4658  }
4659 
4660 
4661  protected:
4662  llrp_u32_t m_AccessPassword;
4663 
4666  public:
4667  static const CFieldDescriptor
4668  s_fdAccessPassword;
4670 
4672  inline llrp_u32_t
4674  {
4675  return m_AccessPassword;
4676  }
4677 
4679  inline void
4681  llrp_u32_t value)
4682  {
4683  m_AccessPassword = value;
4684  }
4685 
4686 
4687  protected:
4688  llrp_u2_t m_MB;
4689 
4692  public:
4693  static const CFieldDescriptor
4694  s_fdMB;
4696 
4698  inline llrp_u2_t
4699  getMB (void)
4700  {
4701  return m_MB;
4702  }
4703 
4705  inline void
4707  llrp_u2_t value)
4708  {
4709  m_MB = value;
4710  }
4711 
4712 
4713  protected:
4714  llrp_u16_t m_BlockPointer;
4715 
4718  public:
4719  static const CFieldDescriptor
4720  s_fdBlockPointer;
4722 
4724  inline llrp_u16_t
4726  {
4727  return m_BlockPointer;
4728  }
4729 
4731  inline void
4733  llrp_u16_t value)
4734  {
4735  m_BlockPointer = value;
4736  }
4737 
4738 
4739  protected:
4740  llrp_u16_t m_BlockRange;
4741 
4744  public:
4745  static const CFieldDescriptor
4746  s_fdBlockRange;
4748 
4750  inline llrp_u16_t
4752  {
4753  return m_BlockRange;
4754  }
4755 
4757  inline void
4759  llrp_u16_t value)
4760  {
4761  m_BlockRange = value;
4762  }
4763 
4764 
4765 
4766  protected:
4767  std::list<CParameter *> m_listCustom;
4768 
4769  public:
4771  inline std::list<CParameter *>::iterator
4773  {
4774  return m_listCustom.begin();
4775  }
4776 
4778  inline std::list<CParameter *>::iterator
4779  endCustom (void)
4780  {
4781  return m_listCustom.end();
4782  }
4783 
4785  inline void
4787  {
4788  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4789  }
4790 
4792  inline int
4794  {
4795  return (int) (m_listCustom.size());
4796  }
4797 
4798  EResultCode
4800  addCustom (
4801  CParameter * pValue);
4802 
4803 
4804 };
4805 
4806 
4834 {
4835  public:
4838 
4841 
4842  static const CFieldDescriptor * const
4843  s_apFieldDescriptorTable[];
4844 
4845  static const CTypeDescriptor
4846  s_typeDescriptor;
4847 
4848  void
4849  decodeFields (
4850  CDecoderStream * pDecoderStream);
4851 
4852  void
4853  assimilateSubParameters (
4854  CErrorDetails * pError);
4855 
4856  void
4857  encode (
4858  CEncoderStream * pEncoderStream) const;
4859 
4860 
4861  llrp_bool_t
4862  isAllowedIn (
4863  const CTypeDescriptor * pEnclosingElementType) const;
4864 
4865 
4866  static CElement *
4867  s_construct (void);
4868 
4869  static void
4870  s_decodeFields (
4871  CDecoderStream * pDecoderStream,
4872  CElement * pElement);
4874 
4875 
4876  protected:
4877  EImpinjGetBlockPermalockStatusResultType m_eResult;
4878 
4881  public:
4882  static const CFieldDescriptor
4883  s_fdResult;
4885 
4887  inline EImpinjGetBlockPermalockStatusResultType
4888  getResult (void)
4889  {
4890  return m_eResult;
4891  }
4892 
4894  inline void
4896  EImpinjGetBlockPermalockStatusResultType value)
4897  {
4898  m_eResult = value;
4899  }
4900 
4901 
4902  protected:
4903  llrp_u16_t m_OpSpecID;
4904 
4907  public:
4908  static const CFieldDescriptor
4909  s_fdOpSpecID;
4911 
4913  inline llrp_u16_t
4915  {
4916  return m_OpSpecID;
4917  }
4918 
4920  inline void
4922  llrp_u16_t value)
4923  {
4924  m_OpSpecID = value;
4925  }
4926 
4927 
4928  protected:
4929  llrp_u16v_t m_PermalockStatus;
4930 
4933  public:
4934  static const CFieldDescriptor
4935  s_fdPermalockStatus;
4937 
4939  inline llrp_u16v_t
4941  {
4942  return m_PermalockStatus;
4943  }
4944 
4946  inline void
4948  llrp_u16v_t value)
4949  {
4950  m_PermalockStatus = value;
4951  }
4952 
4953 
4954 
4955  protected:
4956  std::list<CParameter *> m_listCustom;
4957 
4958  public:
4960  inline std::list<CParameter *>::iterator
4962  {
4963  return m_listCustom.begin();
4964  }
4965 
4967  inline std::list<CParameter *>::iterator
4968  endCustom (void)
4969  {
4970  return m_listCustom.end();
4971  }
4972 
4974  inline void
4976  {
4977  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4978  }
4979 
4981  inline int
4983  {
4984  return (int) (m_listCustom.size());
4985  }
4986 
4987  EResultCode
4989  addCustom (
4990  CParameter * pValue);
4991 
4992 
4993 };
4994 
4995 
5025 class CImpinjSetQTConfig : public CParameter
5026 {
5027  public:
5028  CImpinjSetQTConfig (void);
5029  ~CImpinjSetQTConfig (void);
5030 
5033 
5034  static const CFieldDescriptor * const
5035  s_apFieldDescriptorTable[];
5036 
5037  static const CTypeDescriptor
5038  s_typeDescriptor;
5039 
5040  void
5041  decodeFields (
5042  CDecoderStream * pDecoderStream);
5043 
5044  void
5045  assimilateSubParameters (
5046  CErrorDetails * pError);
5047 
5048  void
5049  encode (
5050  CEncoderStream * pEncoderStream) const;
5051 
5052 
5053  llrp_bool_t
5054  isAllowedIn (
5055  const CTypeDescriptor * pEnclosingElementType) const;
5056 
5057 
5058  static CElement *
5059  s_construct (void);
5060 
5061  static void
5062  s_decodeFields (
5063  CDecoderStream * pDecoderStream,
5064  CElement * pElement);
5066 
5067 
5068  protected:
5069  llrp_u16_t m_OpSpecID;
5070 
5073  public:
5074  static const CFieldDescriptor
5075  s_fdOpSpecID;
5077 
5079  inline llrp_u16_t
5081  {
5082  return m_OpSpecID;
5083  }
5084 
5086  inline void
5088  llrp_u16_t value)
5089  {
5090  m_OpSpecID = value;
5091  }
5092 
5093 
5094  protected:
5095  llrp_u32_t m_AccessPassword;
5096 
5099  public:
5100  static const CFieldDescriptor
5101  s_fdAccessPassword;
5103 
5105  inline llrp_u32_t
5107  {
5108  return m_AccessPassword;
5109  }
5110 
5112  inline void
5114  llrp_u32_t value)
5115  {
5116  m_AccessPassword = value;
5117  }
5118 
5119 
5120  protected:
5121  EImpinjQTDataProfile m_eDataProfile;
5122 
5125  public:
5126  static const CFieldDescriptor
5127  s_fdDataProfile;
5129 
5131  inline EImpinjQTDataProfile
5133  {
5134  return m_eDataProfile;
5135  }
5136 
5138  inline void
5140  EImpinjQTDataProfile value)
5141  {
5142  m_eDataProfile = value;
5143  }
5144 
5145 
5146  protected:
5147  EImpinjQTAccessRange m_eAccessRange;
5148 
5151  public:
5152  static const CFieldDescriptor
5153  s_fdAccessRange;
5155 
5157  inline EImpinjQTAccessRange
5159  {
5160  return m_eAccessRange;
5161  }
5162 
5164  inline void
5166  EImpinjQTAccessRange value)
5167  {
5168  m_eAccessRange = value;
5169  }
5170 
5171 
5172  protected:
5173  EImpinjQTPersistence m_ePersistence;
5174 
5177  public:
5178  static const CFieldDescriptor
5179  s_fdPersistence;
5181 
5183  inline EImpinjQTPersistence
5185  {
5186  return m_ePersistence;
5187  }
5188 
5190  inline void
5192  EImpinjQTPersistence value)
5193  {
5194  m_ePersistence = value;
5195  }
5196 
5197 
5198 
5199  protected:
5200  std::list<CParameter *> m_listCustom;
5201 
5202  public:
5204  inline std::list<CParameter *>::iterator
5206  {
5207  return m_listCustom.begin();
5208  }
5209 
5211  inline std::list<CParameter *>::iterator
5212  endCustom (void)
5213  {
5214  return m_listCustom.end();
5215  }
5216 
5218  inline void
5220  {
5221  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5222  }
5223 
5225  inline int
5227  {
5228  return (int) (m_listCustom.size());
5229  }
5230 
5231  EResultCode
5233  addCustom (
5234  CParameter * pValue);
5235 
5236 
5237 };
5238 
5239 
5265 class CImpinjSetQTConfigOpSpecResult : public CParameter
5266 {
5267  public:
5270 
5273 
5274  static const CFieldDescriptor * const
5275  s_apFieldDescriptorTable[];
5276 
5277  static const CTypeDescriptor
5278  s_typeDescriptor;
5279 
5280  void
5281  decodeFields (
5282  CDecoderStream * pDecoderStream);
5283 
5284  void
5285  assimilateSubParameters (
5286  CErrorDetails * pError);
5287 
5288  void
5289  encode (
5290  CEncoderStream * pEncoderStream) const;
5291 
5292 
5293  llrp_bool_t
5294  isAllowedIn (
5295  const CTypeDescriptor * pEnclosingElementType) const;
5296 
5297 
5298  static CElement *
5299  s_construct (void);
5300 
5301  static void
5302  s_decodeFields (
5303  CDecoderStream * pDecoderStream,
5304  CElement * pElement);
5306 
5307 
5308  protected:
5309  EImpinjSetQTConfigResultType m_eResult;
5310 
5313  public:
5314  static const CFieldDescriptor
5315  s_fdResult;
5317 
5319  inline EImpinjSetQTConfigResultType
5320  getResult (void)
5321  {
5322  return m_eResult;
5323  }
5324 
5326  inline void
5328  EImpinjSetQTConfigResultType value)
5329  {
5330  m_eResult = value;
5331  }
5332 
5333 
5334  protected:
5335  llrp_u16_t m_OpSpecID;
5336 
5339  public:
5340  static const CFieldDescriptor
5341  s_fdOpSpecID;
5343 
5345  inline llrp_u16_t
5347  {
5348  return m_OpSpecID;
5349  }
5350 
5352  inline void
5354  llrp_u16_t value)
5355  {
5356  m_OpSpecID = value;
5357  }
5358 
5359 
5360 
5361  protected:
5362  std::list<CParameter *> m_listCustom;
5363 
5364  public:
5366  inline std::list<CParameter *>::iterator
5368  {
5369  return m_listCustom.begin();
5370  }
5371 
5373  inline std::list<CParameter *>::iterator
5374  endCustom (void)
5375  {
5376  return m_listCustom.end();
5377  }
5378 
5380  inline void
5382  {
5383  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5384  }
5385 
5387  inline int
5389  {
5390  return (int) (m_listCustom.size());
5391  }
5392 
5393  EResultCode
5395  addCustom (
5396  CParameter * pValue);
5397 
5398 
5399 };
5400 
5401 
5427 class CImpinjGetQTConfig : public CParameter
5428 {
5429  public:
5430  CImpinjGetQTConfig (void);
5431  ~CImpinjGetQTConfig (void);
5432 
5435 
5436  static const CFieldDescriptor * const
5437  s_apFieldDescriptorTable[];
5438 
5439  static const CTypeDescriptor
5440  s_typeDescriptor;
5441 
5442  void
5443  decodeFields (
5444  CDecoderStream * pDecoderStream);
5445 
5446  void
5447  assimilateSubParameters (
5448  CErrorDetails * pError);
5449 
5450  void
5451  encode (
5452  CEncoderStream * pEncoderStream) const;
5453 
5454 
5455  llrp_bool_t
5456  isAllowedIn (
5457  const CTypeDescriptor * pEnclosingElementType) const;
5458 
5459 
5460  static CElement *
5461  s_construct (void);
5462 
5463  static void
5464  s_decodeFields (
5465  CDecoderStream * pDecoderStream,
5466  CElement * pElement);
5468 
5469 
5470  protected:
5471  llrp_u16_t m_OpSpecID;
5472 
5475  public:
5476  static const CFieldDescriptor
5477  s_fdOpSpecID;
5479 
5481  inline llrp_u16_t
5483  {
5484  return m_OpSpecID;
5485  }
5486 
5488  inline void
5490  llrp_u16_t value)
5491  {
5492  m_OpSpecID = value;
5493  }
5494 
5495 
5496  protected:
5497  llrp_u32_t m_AccessPassword;
5498 
5501  public:
5502  static const CFieldDescriptor
5503  s_fdAccessPassword;
5505 
5507  inline llrp_u32_t
5509  {
5510  return m_AccessPassword;
5511  }
5512 
5514  inline void
5516  llrp_u32_t value)
5517  {
5518  m_AccessPassword = value;
5519  }
5520 
5521 
5522 
5523  protected:
5524  std::list<CParameter *> m_listCustom;
5525 
5526  public:
5528  inline std::list<CParameter *>::iterator
5530  {
5531  return m_listCustom.begin();
5532  }
5533 
5535  inline std::list<CParameter *>::iterator
5536  endCustom (void)
5537  {
5538  return m_listCustom.end();
5539  }
5540 
5542  inline void
5544  {
5545  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5546  }
5547 
5549  inline int
5551  {
5552  return (int) (m_listCustom.size());
5553  }
5554 
5555  EResultCode
5557  addCustom (
5558  CParameter * pValue);
5559 
5560 
5561 };
5562 
5563 
5592 class CImpinjGetQTConfigOpSpecResult : public CParameter
5593 {
5594  public:
5597 
5600 
5601  static const CFieldDescriptor * const
5602  s_apFieldDescriptorTable[];
5603 
5604  static const CTypeDescriptor
5605  s_typeDescriptor;
5606 
5607  void
5608  decodeFields (
5609  CDecoderStream * pDecoderStream);
5610 
5611  void
5612  assimilateSubParameters (
5613  CErrorDetails * pError);
5614 
5615  void
5616  encode (
5617  CEncoderStream * pEncoderStream) const;
5618 
5619 
5620  llrp_bool_t
5621  isAllowedIn (
5622  const CTypeDescriptor * pEnclosingElementType) const;
5623 
5624 
5625  static CElement *
5626  s_construct (void);
5627 
5628  static void
5629  s_decodeFields (
5630  CDecoderStream * pDecoderStream,
5631  CElement * pElement);
5633 
5634 
5635  protected:
5636  EImpinjGetQTConfigResultType m_eResult;
5637 
5640  public:
5641  static const CFieldDescriptor
5642  s_fdResult;
5644 
5646  inline EImpinjGetQTConfigResultType
5647  getResult (void)
5648  {
5649  return m_eResult;
5650  }
5651 
5653  inline void
5655  EImpinjGetQTConfigResultType value)
5656  {
5657  m_eResult = value;
5658  }
5659 
5660 
5661  protected:
5662  llrp_u16_t m_OpSpecID;
5663 
5666  public:
5667  static const CFieldDescriptor
5668  s_fdOpSpecID;
5670 
5672  inline llrp_u16_t
5674  {
5675  return m_OpSpecID;
5676  }
5677 
5679  inline void
5681  llrp_u16_t value)
5682  {
5683  m_OpSpecID = value;
5684  }
5685 
5686 
5687  protected:
5688  EImpinjQTDataProfile m_eDataProfile;
5689 
5692  public:
5693  static const CFieldDescriptor
5694  s_fdDataProfile;
5696 
5698  inline EImpinjQTDataProfile
5700  {
5701  return m_eDataProfile;
5702  }
5703 
5705  inline void
5707  EImpinjQTDataProfile value)
5708  {
5709  m_eDataProfile = value;
5710  }
5711 
5712 
5713  protected:
5714  EImpinjQTAccessRange m_eAccessRange;
5715 
5718  public:
5719  static const CFieldDescriptor
5720  s_fdAccessRange;
5722 
5724  inline EImpinjQTAccessRange
5726  {
5727  return m_eAccessRange;
5728  }
5729 
5731  inline void
5733  EImpinjQTAccessRange value)
5734  {
5735  m_eAccessRange = value;
5736  }
5737 
5738 
5739 
5740  protected:
5741  std::list<CParameter *> m_listCustom;
5742 
5743  public:
5745  inline std::list<CParameter *>::iterator
5747  {
5748  return m_listCustom.begin();
5749  }
5750 
5752  inline std::list<CParameter *>::iterator
5753  endCustom (void)
5754  {
5755  return m_listCustom.end();
5756  }
5757 
5759  inline void
5761  {
5762  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5763  }
5764 
5766  inline int
5768  {
5769  return (int) (m_listCustom.size());
5770  }
5771 
5772  EResultCode
5774  addCustom (
5775  CParameter * pValue);
5776 
5777 
5778 };
5779 
5780 
5811 class CImpinjTagReportContentSelector : public CParameter
5812 {
5813  public:
5816 
5819 
5820  static const CFieldDescriptor * const
5821  s_apFieldDescriptorTable[];
5822 
5823  static const CTypeDescriptor
5824  s_typeDescriptor;
5825 
5826  void
5827  decodeFields (
5828  CDecoderStream * pDecoderStream);
5829 
5830  void
5831  assimilateSubParameters (
5832  CErrorDetails * pError);
5833 
5834  void
5835  encode (
5836  CEncoderStream * pEncoderStream) const;
5837 
5838 
5839  llrp_bool_t
5840  isAllowedIn (
5841  const CTypeDescriptor * pEnclosingElementType) const;
5842 
5843 
5844  static CElement *
5845  s_construct (void);
5846 
5847  static void
5848  s_decodeFields (
5849  CDecoderStream * pDecoderStream,
5850  CElement * pElement);
5852 
5853 
5854 
5855  protected:
5856  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5857 
5858  public:
5862  {
5863  return m_pImpinjEnableSerializedTID;
5864  }
5865 
5867  EResultCode
5868  setImpinjEnableSerializedTID (
5869  CImpinjEnableSerializedTID * pValue);
5870 
5871 
5872  protected:
5873  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5874 
5875  public:
5877  inline CImpinjEnableRFPhaseAngle *
5879  {
5880  return m_pImpinjEnableRFPhaseAngle;
5881  }
5882 
5884  EResultCode
5885  setImpinjEnableRFPhaseAngle (
5886  CImpinjEnableRFPhaseAngle * pValue);
5887 
5888 
5889  protected:
5890  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5891 
5892  public:
5894  inline CImpinjEnablePeakRSSI *
5896  {
5897  return m_pImpinjEnablePeakRSSI;
5898  }
5899 
5901  EResultCode
5902  setImpinjEnablePeakRSSI (
5903  CImpinjEnablePeakRSSI * pValue);
5904 
5905 
5906  protected:
5907  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5908 
5909  public:
5913  {
5914  return m_pImpinjEnableGPSCoordinates;
5915  }
5916 
5918  EResultCode
5919  setImpinjEnableGPSCoordinates (
5920  CImpinjEnableGPSCoordinates * pValue);
5921 
5922 
5923  protected:
5924  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5925 
5926  public:
5930  {
5931  return m_pImpinjEnableOptimizedRead;
5932  }
5933 
5935  EResultCode
5936  setImpinjEnableOptimizedRead (
5937  CImpinjEnableOptimizedRead * pValue);
5938 
5939 
5940  protected:
5941  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5942 
5943  public:
5947  {
5948  return m_pImpinjEnableRFDopplerFrequency;
5949  }
5950 
5952  EResultCode
5953  setImpinjEnableRFDopplerFrequency (
5955 
5956 
5957  protected:
5958  CImpinjEnableTxPower * m_pImpinjEnableTxPower;
5959 
5960  public:
5962  inline CImpinjEnableTxPower *
5964  {
5965  return m_pImpinjEnableTxPower;
5966  }
5967 
5969  EResultCode
5970  setImpinjEnableTxPower (
5971  CImpinjEnableTxPower * pValue);
5972 
5973 
5974  protected:
5975  std::list<CParameter *> m_listCustom;
5976 
5977  public:
5979  inline std::list<CParameter *>::iterator
5981  {
5982  return m_listCustom.begin();
5983  }
5984 
5986  inline std::list<CParameter *>::iterator
5987  endCustom (void)
5988  {
5989  return m_listCustom.end();
5990  }
5991 
5993  inline void
5995  {
5996  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5997  }
5998 
6000  inline int
6002  {
6003  return (int) (m_listCustom.size());
6004  }
6005 
6006  EResultCode
6008  addCustom (
6009  CParameter * pValue);
6010 
6011 
6012 };
6013 
6014 
6038 class CImpinjEnableSerializedTID : public CParameter
6039 {
6040  public:
6043 
6046 
6047  static const CFieldDescriptor * const
6048  s_apFieldDescriptorTable[];
6049 
6050  static const CTypeDescriptor
6051  s_typeDescriptor;
6052 
6053  void
6054  decodeFields (
6055  CDecoderStream * pDecoderStream);
6056 
6057  void
6058  assimilateSubParameters (
6059  CErrorDetails * pError);
6060 
6061  void
6062  encode (
6063  CEncoderStream * pEncoderStream) const;
6064 
6065 
6066  llrp_bool_t
6067  isAllowedIn (
6068  const CTypeDescriptor * pEnclosingElementType) const;
6069 
6070 
6071  static CElement *
6072  s_construct (void);
6073 
6074  static void
6075  s_decodeFields (
6076  CDecoderStream * pDecoderStream,
6077  CElement * pElement);
6079 
6080 
6081  protected:
6082  EImpinjSerializedTIDMode m_eSerializedTIDMode;
6083 
6086  public:
6087  static const CFieldDescriptor
6088  s_fdSerializedTIDMode;
6090 
6092  inline EImpinjSerializedTIDMode
6094  {
6095  return m_eSerializedTIDMode;
6096  }
6097 
6099  inline void
6101  EImpinjSerializedTIDMode value)
6102  {
6103  m_eSerializedTIDMode = value;
6104  }
6105 
6106 
6107 
6108  protected:
6109  std::list<CParameter *> m_listCustom;
6110 
6111  public:
6113  inline std::list<CParameter *>::iterator
6115  {
6116  return m_listCustom.begin();
6117  }
6118 
6120  inline std::list<CParameter *>::iterator
6121  endCustom (void)
6122  {
6123  return m_listCustom.end();
6124  }
6125 
6127  inline void
6129  {
6130  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6131  }
6132 
6134  inline int
6136  {
6137  return (int) (m_listCustom.size());
6138  }
6139 
6140  EResultCode
6142  addCustom (
6143  CParameter * pValue);
6144 
6145 
6146 };
6147 
6148 
6172 class CImpinjEnableRFPhaseAngle : public CParameter
6173 {
6174  public:
6176  ~CImpinjEnableRFPhaseAngle (void);
6177 
6180 
6181  static const CFieldDescriptor * const
6182  s_apFieldDescriptorTable[];
6183 
6184  static const CTypeDescriptor
6185  s_typeDescriptor;
6186 
6187  void
6188  decodeFields (
6189  CDecoderStream * pDecoderStream);
6190 
6191  void
6192  assimilateSubParameters (
6193  CErrorDetails * pError);
6194 
6195  void
6196  encode (
6197  CEncoderStream * pEncoderStream) const;
6198 
6199 
6200  llrp_bool_t
6201  isAllowedIn (
6202  const CTypeDescriptor * pEnclosingElementType) const;
6203 
6204 
6205  static CElement *
6206  s_construct (void);
6207 
6208  static void
6209  s_decodeFields (
6210  CDecoderStream * pDecoderStream,
6211  CElement * pElement);
6213 
6214 
6215  protected:
6216  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
6217 
6220  public:
6221  static const CFieldDescriptor
6222  s_fdRFPhaseAngleMode;
6224 
6226  inline EImpinjRFPhaseAngleMode
6228  {
6229  return m_eRFPhaseAngleMode;
6230  }
6231 
6233  inline void
6235  EImpinjRFPhaseAngleMode value)
6236  {
6237  m_eRFPhaseAngleMode = value;
6238  }
6239 
6240 
6241 
6242  protected:
6243  std::list<CParameter *> m_listCustom;
6244 
6245  public:
6247  inline std::list<CParameter *>::iterator
6249  {
6250  return m_listCustom.begin();
6251  }
6252 
6254  inline std::list<CParameter *>::iterator
6255  endCustom (void)
6256  {
6257  return m_listCustom.end();
6258  }
6259 
6261  inline void
6263  {
6264  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6265  }
6266 
6268  inline int
6270  {
6271  return (int) (m_listCustom.size());
6272  }
6273 
6274  EResultCode
6276  addCustom (
6277  CParameter * pValue);
6278 
6279 
6280 };
6281 
6282 
6306 class CImpinjEnablePeakRSSI : public CParameter
6307 {
6308  public:
6309  CImpinjEnablePeakRSSI (void);
6310  ~CImpinjEnablePeakRSSI (void);
6311 
6314 
6315  static const CFieldDescriptor * const
6316  s_apFieldDescriptorTable[];
6317 
6318  static const CTypeDescriptor
6319  s_typeDescriptor;
6320 
6321  void
6322  decodeFields (
6323  CDecoderStream * pDecoderStream);
6324 
6325  void
6326  assimilateSubParameters (
6327  CErrorDetails * pError);
6328 
6329  void
6330  encode (
6331  CEncoderStream * pEncoderStream) const;
6332 
6333 
6334  llrp_bool_t
6335  isAllowedIn (
6336  const CTypeDescriptor * pEnclosingElementType) const;
6337 
6338 
6339  static CElement *
6340  s_construct (void);
6341 
6342  static void
6343  s_decodeFields (
6344  CDecoderStream * pDecoderStream,
6345  CElement * pElement);
6347 
6348 
6349  protected:
6350  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6351 
6354  public:
6355  static const CFieldDescriptor
6356  s_fdPeakRSSIMode;
6358 
6360  inline EImpinjPeakRSSIMode
6362  {
6363  return m_ePeakRSSIMode;
6364  }
6365 
6367  inline void
6369  EImpinjPeakRSSIMode value)
6370  {
6371  m_ePeakRSSIMode = value;
6372  }
6373 
6374 
6375 
6376  protected:
6377  std::list<CParameter *> m_listCustom;
6378 
6379  public:
6381  inline std::list<CParameter *>::iterator
6383  {
6384  return m_listCustom.begin();
6385  }
6386 
6388  inline std::list<CParameter *>::iterator
6389  endCustom (void)
6390  {
6391  return m_listCustom.end();
6392  }
6393 
6395  inline void
6397  {
6398  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6399  }
6400 
6402  inline int
6404  {
6405  return (int) (m_listCustom.size());
6406  }
6407 
6408  EResultCode
6410  addCustom (
6411  CParameter * pValue);
6412 
6413 
6414 };
6415 
6416 
6440 class CImpinjEnableGPSCoordinates : public CParameter
6441 {
6442  public:
6445 
6448 
6449  static const CFieldDescriptor * const
6450  s_apFieldDescriptorTable[];
6451 
6452  static const CTypeDescriptor
6453  s_typeDescriptor;
6454 
6455  void
6456  decodeFields (
6457  CDecoderStream * pDecoderStream);
6458 
6459  void
6460  assimilateSubParameters (
6461  CErrorDetails * pError);
6462 
6463  void
6464  encode (
6465  CEncoderStream * pEncoderStream) const;
6466 
6467 
6468  llrp_bool_t
6469  isAllowedIn (
6470  const CTypeDescriptor * pEnclosingElementType) const;
6471 
6472 
6473  static CElement *
6474  s_construct (void);
6475 
6476  static void
6477  s_decodeFields (
6478  CDecoderStream * pDecoderStream,
6479  CElement * pElement);
6481 
6482 
6483  protected:
6484  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6485 
6488  public:
6489  static const CFieldDescriptor
6490  s_fdGPSCoordinatesMode;
6492 
6494  inline EImpinjGPSCoordinatesMode
6496  {
6497  return m_eGPSCoordinatesMode;
6498  }
6499 
6501  inline void
6503  EImpinjGPSCoordinatesMode value)
6504  {
6505  m_eGPSCoordinatesMode = value;
6506  }
6507 
6508 
6509 
6510  protected:
6511  std::list<CParameter *> m_listCustom;
6512 
6513  public:
6515  inline std::list<CParameter *>::iterator
6517  {
6518  return m_listCustom.begin();
6519  }
6520 
6522  inline std::list<CParameter *>::iterator
6523  endCustom (void)
6524  {
6525  return m_listCustom.end();
6526  }
6527 
6529  inline void
6531  {
6532  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6533  }
6534 
6536  inline int
6538  {
6539  return (int) (m_listCustom.size());
6540  }
6541 
6542  EResultCode
6544  addCustom (
6545  CParameter * pValue);
6546 
6547 
6548 };
6549 
6550 
6576 class CImpinjSerializedTID : public CParameter
6577 {
6578  public:
6579  CImpinjSerializedTID (void);
6580  ~CImpinjSerializedTID (void);
6581 
6584 
6585  static const CFieldDescriptor * const
6586  s_apFieldDescriptorTable[];
6587 
6588  static const CTypeDescriptor
6589  s_typeDescriptor;
6590 
6591  void
6592  decodeFields (
6593  CDecoderStream * pDecoderStream);
6594 
6595  void
6596  assimilateSubParameters (
6597  CErrorDetails * pError);
6598 
6599  void
6600  encode (
6601  CEncoderStream * pEncoderStream) const;
6602 
6603 
6604  llrp_bool_t
6605  isAllowedIn (
6606  const CTypeDescriptor * pEnclosingElementType) const;
6607 
6608 
6609  static CElement *
6610  s_construct (void);
6611 
6612  static void
6613  s_decodeFields (
6614  CDecoderStream * pDecoderStream,
6615  CElement * pElement);
6617 
6618 
6619  protected:
6620  llrp_u16v_t m_TID;
6621 
6624  public:
6625  static const CFieldDescriptor
6626  s_fdTID;
6628 
6630  inline llrp_u16v_t
6631  getTID (void)
6632  {
6633  return m_TID;
6634  }
6635 
6637  inline void
6639  llrp_u16v_t value)
6640  {
6641  m_TID = value;
6642  }
6643 
6644 
6645 
6646  protected:
6647  CImpinjTIDParity * m_pImpinjTIDParity;
6648 
6649  public:
6651  inline CImpinjTIDParity *
6653  {
6654  return m_pImpinjTIDParity;
6655  }
6656 
6658  EResultCode
6659  setImpinjTIDParity (
6660  CImpinjTIDParity * pValue);
6661 
6662 
6663  protected:
6664  std::list<CParameter *> m_listCustom;
6665 
6666  public:
6668  inline std::list<CParameter *>::iterator
6670  {
6671  return m_listCustom.begin();
6672  }
6673 
6675  inline std::list<CParameter *>::iterator
6676  endCustom (void)
6677  {
6678  return m_listCustom.end();
6679  }
6680 
6682  inline void
6684  {
6685  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6686  }
6687 
6689  inline int
6691  {
6692  return (int) (m_listCustom.size());
6693  }
6694 
6695  EResultCode
6697  addCustom (
6698  CParameter * pValue);
6699 
6700 
6701 };
6702 
6703 
6728 class CImpinjRFPhaseAngle : public CParameter
6729 {
6730  public:
6731  CImpinjRFPhaseAngle (void);
6732  ~CImpinjRFPhaseAngle (void);
6733 
6736 
6737  static const CFieldDescriptor * const
6738  s_apFieldDescriptorTable[];
6739 
6740  static const CTypeDescriptor
6741  s_typeDescriptor;
6742 
6743  void
6744  decodeFields (
6745  CDecoderStream * pDecoderStream);
6746 
6747  void
6748  assimilateSubParameters (
6749  CErrorDetails * pError);
6750 
6751  void
6752  encode (
6753  CEncoderStream * pEncoderStream) const;
6754 
6755 
6756  llrp_bool_t
6757  isAllowedIn (
6758  const CTypeDescriptor * pEnclosingElementType) const;
6759 
6760 
6761  static CElement *
6762  s_construct (void);
6763 
6764  static void
6765  s_decodeFields (
6766  CDecoderStream * pDecoderStream,
6767  CElement * pElement);
6769 
6770 
6771  protected:
6772  llrp_u16_t m_PhaseAngle;
6773 
6776  public:
6777  static const CFieldDescriptor
6778  s_fdPhaseAngle;
6780 
6782  inline llrp_u16_t
6784  {
6785  return m_PhaseAngle;
6786  }
6787 
6789  inline void
6791  llrp_u16_t value)
6792  {
6793  m_PhaseAngle = value;
6794  }
6795 
6796 
6797 
6798  protected:
6799  std::list<CParameter *> m_listCustom;
6800 
6801  public:
6803  inline std::list<CParameter *>::iterator
6805  {
6806  return m_listCustom.begin();
6807  }
6808 
6810  inline std::list<CParameter *>::iterator
6811  endCustom (void)
6812  {
6813  return m_listCustom.end();
6814  }
6815 
6817  inline void
6819  {
6820  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6821  }
6822 
6824  inline int
6826  {
6827  return (int) (m_listCustom.size());
6828  }
6829 
6830  EResultCode
6832  addCustom (
6833  CParameter * pValue);
6834 
6835 
6836 };
6837 
6838 
6863 class CImpinjPeakRSSI : public CParameter
6864 {
6865  public:
6866  CImpinjPeakRSSI (void);
6867  ~CImpinjPeakRSSI (void);
6868 
6871 
6872  static const CFieldDescriptor * const
6873  s_apFieldDescriptorTable[];
6874 
6875  static const CTypeDescriptor
6876  s_typeDescriptor;
6877 
6878  void
6879  decodeFields (
6880  CDecoderStream * pDecoderStream);
6881 
6882  void
6883  assimilateSubParameters (
6884  CErrorDetails * pError);
6885 
6886  void
6887  encode (
6888  CEncoderStream * pEncoderStream) const;
6889 
6890 
6891  llrp_bool_t
6892  isAllowedIn (
6893  const CTypeDescriptor * pEnclosingElementType) const;
6894 
6895 
6896  static CElement *
6897  s_construct (void);
6898 
6899  static void
6900  s_decodeFields (
6901  CDecoderStream * pDecoderStream,
6902  CElement * pElement);
6904 
6905 
6906  protected:
6907  llrp_s16_t m_RSSI;
6908 
6911  public:
6912  static const CFieldDescriptor
6913  s_fdRSSI;
6915 
6917  inline llrp_s16_t
6918  getRSSI (void)
6919  {
6920  return m_RSSI;
6921  }
6922 
6924  inline void
6926  llrp_s16_t value)
6927  {
6928  m_RSSI = value;
6929  }
6930 
6931 
6932 
6933  protected:
6934  std::list<CParameter *> m_listCustom;
6935 
6936  public:
6938  inline std::list<CParameter *>::iterator
6940  {
6941  return m_listCustom.begin();
6942  }
6943 
6945  inline std::list<CParameter *>::iterator
6946  endCustom (void)
6947  {
6948  return m_listCustom.end();
6949  }
6950 
6952  inline void
6954  {
6955  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6956  }
6957 
6959  inline int
6961  {
6962  return (int) (m_listCustom.size());
6963  }
6964 
6965  EResultCode
6967  addCustom (
6968  CParameter * pValue);
6969 
6970 
6971 };
6972 
6973 
6999 class CImpinjGPSCoordinates : public CParameter
7000 {
7001  public:
7002  CImpinjGPSCoordinates (void);
7003  ~CImpinjGPSCoordinates (void);
7004 
7007 
7008  static const CFieldDescriptor * const
7009  s_apFieldDescriptorTable[];
7010 
7011  static const CTypeDescriptor
7012  s_typeDescriptor;
7013 
7014  void
7015  decodeFields (
7016  CDecoderStream * pDecoderStream);
7017 
7018  void
7019  assimilateSubParameters (
7020  CErrorDetails * pError);
7021 
7022  void
7023  encode (
7024  CEncoderStream * pEncoderStream) const;
7025 
7026 
7027  llrp_bool_t
7028  isAllowedIn (
7029  const CTypeDescriptor * pEnclosingElementType) const;
7030 
7031 
7032  static CElement *
7033  s_construct (void);
7034 
7035  static void
7036  s_decodeFields (
7037  CDecoderStream * pDecoderStream,
7038  CElement * pElement);
7040 
7041 
7042  protected:
7043  llrp_s32_t m_Latitude;
7044 
7047  public:
7048  static const CFieldDescriptor
7049  s_fdLatitude;
7051 
7053  inline llrp_s32_t
7055  {
7056  return m_Latitude;
7057  }
7058 
7060  inline void
7062  llrp_s32_t value)
7063  {
7064  m_Latitude = value;
7065  }
7066 
7067 
7068  protected:
7069  llrp_s32_t m_Longitude;
7070 
7073  public:
7074  static const CFieldDescriptor
7075  s_fdLongitude;
7077 
7079  inline llrp_s32_t
7081  {
7082  return m_Longitude;
7083  }
7084 
7086  inline void
7088  llrp_s32_t value)
7089  {
7090  m_Longitude = value;
7091  }
7092 
7093 
7094 
7095  protected:
7096  std::list<CParameter *> m_listCustom;
7097 
7098  public:
7100  inline std::list<CParameter *>::iterator
7102  {
7103  return m_listCustom.begin();
7104  }
7105 
7107  inline std::list<CParameter *>::iterator
7108  endCustom (void)
7109  {
7110  return m_listCustom.end();
7111  }
7112 
7114  inline void
7116  {
7117  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7118  }
7119 
7121  inline int
7123  {
7124  return (int) (m_listCustom.size());
7125  }
7126 
7127  EResultCode
7129  addCustom (
7130  CParameter * pValue);
7131 
7132 
7133 };
7134 
7135 
7160 class CImpinjLoopSpec : public CParameter
7161 {
7162  public:
7163  CImpinjLoopSpec (void);
7164  ~CImpinjLoopSpec (void);
7165 
7168 
7169  static const CFieldDescriptor * const
7170  s_apFieldDescriptorTable[];
7171 
7172  static const CTypeDescriptor
7173  s_typeDescriptor;
7174 
7175  void
7176  decodeFields (
7177  CDecoderStream * pDecoderStream);
7178 
7179  void
7180  assimilateSubParameters (
7181  CErrorDetails * pError);
7182 
7183  void
7184  encode (
7185  CEncoderStream * pEncoderStream) const;
7186 
7187 
7188  llrp_bool_t
7189  isAllowedIn (
7190  const CTypeDescriptor * pEnclosingElementType) const;
7191 
7192 
7193  static CElement *
7194  s_construct (void);
7195 
7196  static void
7197  s_decodeFields (
7198  CDecoderStream * pDecoderStream,
7199  CElement * pElement);
7201 
7202 
7203  protected:
7204  llrp_u32_t m_LoopCount;
7205 
7208  public:
7209  static const CFieldDescriptor
7210  s_fdLoopCount;
7212 
7214  inline llrp_u32_t
7216  {
7217  return m_LoopCount;
7218  }
7219 
7221  inline void
7223  llrp_u32_t value)
7224  {
7225  m_LoopCount = value;
7226  }
7227 
7228 
7229 
7230  protected:
7231  std::list<CParameter *> m_listCustom;
7232 
7233  public:
7235  inline std::list<CParameter *>::iterator
7237  {
7238  return m_listCustom.begin();
7239  }
7240 
7242  inline std::list<CParameter *>::iterator
7243  endCustom (void)
7244  {
7245  return m_listCustom.end();
7246  }
7247 
7249  inline void
7251  {
7252  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7253  }
7254 
7256  inline int
7258  {
7259  return (int) (m_listCustom.size());
7260  }
7261 
7262  EResultCode
7264  addCustom (
7265  CParameter * pValue);
7266 
7267 
7268 };
7269 
7270 
7296 class CImpinjGPSNMEASentences : public CParameter
7297 {
7298  public:
7299  CImpinjGPSNMEASentences (void);
7300  ~CImpinjGPSNMEASentences (void);
7301 
7304 
7305  static const CFieldDescriptor * const
7306  s_apFieldDescriptorTable[];
7307 
7308  static const CTypeDescriptor
7309  s_typeDescriptor;
7310 
7311  void
7312  decodeFields (
7313  CDecoderStream * pDecoderStream);
7314 
7315  void
7316  assimilateSubParameters (
7317  CErrorDetails * pError);
7318 
7319  void
7320  encode (
7321  CEncoderStream * pEncoderStream) const;
7322 
7323 
7324  llrp_bool_t
7325  isAllowedIn (
7326  const CTypeDescriptor * pEnclosingElementType) const;
7327 
7328 
7329  static CElement *
7330  s_construct (void);
7331 
7332  static void
7333  s_decodeFields (
7334  CDecoderStream * pDecoderStream,
7335  CElement * pElement);
7337 
7338 
7339 
7340  protected:
7341  CImpinjGGASentence * m_pImpinjGGASentence;
7342 
7343  public:
7345  inline CImpinjGGASentence *
7347  {
7348  return m_pImpinjGGASentence;
7349  }
7350 
7352  EResultCode
7353  setImpinjGGASentence (
7354  CImpinjGGASentence * pValue);
7355 
7356 
7357  protected:
7358  CImpinjRMCSentence * m_pImpinjRMCSentence;
7359 
7360  public:
7362  inline CImpinjRMCSentence *
7364  {
7365  return m_pImpinjRMCSentence;
7366  }
7367 
7369  EResultCode
7370  setImpinjRMCSentence (
7371  CImpinjRMCSentence * pValue);
7372 
7373 
7374  protected:
7375  std::list<CParameter *> m_listCustom;
7376 
7377  public:
7379  inline std::list<CParameter *>::iterator
7381  {
7382  return m_listCustom.begin();
7383  }
7384 
7386  inline std::list<CParameter *>::iterator
7387  endCustom (void)
7388  {
7389  return m_listCustom.end();
7390  }
7391 
7393  inline void
7395  {
7396  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7397  }
7398 
7400  inline int
7402  {
7403  return (int) (m_listCustom.size());
7404  }
7405 
7406  EResultCode
7408  addCustom (
7409  CParameter * pValue);
7410 
7411 
7412 };
7413 
7414 
7438 class CImpinjGGASentence : public CParameter
7439 {
7440  public:
7441  CImpinjGGASentence (void);
7442  ~CImpinjGGASentence (void);
7443 
7446 
7447  static const CFieldDescriptor * const
7448  s_apFieldDescriptorTable[];
7449 
7450  static const CTypeDescriptor
7451  s_typeDescriptor;
7452 
7453  void
7454  decodeFields (
7455  CDecoderStream * pDecoderStream);
7456 
7457  void
7458  assimilateSubParameters (
7459  CErrorDetails * pError);
7460 
7461  void
7462  encode (
7463  CEncoderStream * pEncoderStream) const;
7464 
7465 
7466  llrp_bool_t
7467  isAllowedIn (
7468  const CTypeDescriptor * pEnclosingElementType) const;
7469 
7470 
7471  static CElement *
7472  s_construct (void);
7473 
7474  static void
7475  s_decodeFields (
7476  CDecoderStream * pDecoderStream,
7477  CElement * pElement);
7479 
7480 
7481  protected:
7482  llrp_utf8v_t m_GGASentence;
7483 
7486  public:
7487  static const CFieldDescriptor
7488  s_fdGGASentence;
7490 
7492  inline llrp_utf8v_t
7494  {
7495  return m_GGASentence;
7496  }
7497 
7499  inline void
7501  llrp_utf8v_t value)
7502  {
7503  m_GGASentence = value;
7504  }
7505 
7506 
7507 
7508  protected:
7509  std::list<CParameter *> m_listCustom;
7510 
7511  public:
7513  inline std::list<CParameter *>::iterator
7515  {
7516  return m_listCustom.begin();
7517  }
7518 
7520  inline std::list<CParameter *>::iterator
7521  endCustom (void)
7522  {
7523  return m_listCustom.end();
7524  }
7525 
7527  inline void
7529  {
7530  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7531  }
7532 
7534  inline int
7536  {
7537  return (int) (m_listCustom.size());
7538  }
7539 
7540  EResultCode
7542  addCustom (
7543  CParameter * pValue);
7544 
7545 
7546 };
7547 
7548 
7572 class CImpinjRMCSentence : public CParameter
7573 {
7574  public:
7575  CImpinjRMCSentence (void);
7576  ~CImpinjRMCSentence (void);
7577 
7580 
7581  static const CFieldDescriptor * const
7582  s_apFieldDescriptorTable[];
7583 
7584  static const CTypeDescriptor
7585  s_typeDescriptor;
7586 
7587  void
7588  decodeFields (
7589  CDecoderStream * pDecoderStream);
7590 
7591  void
7592  assimilateSubParameters (
7593  CErrorDetails * pError);
7594 
7595  void
7596  encode (
7597  CEncoderStream * pEncoderStream) const;
7598 
7599 
7600  llrp_bool_t
7601  isAllowedIn (
7602  const CTypeDescriptor * pEnclosingElementType) const;
7603 
7604 
7605  static CElement *
7606  s_construct (void);
7607 
7608  static void
7609  s_decodeFields (
7610  CDecoderStream * pDecoderStream,
7611  CElement * pElement);
7613 
7614 
7615  protected:
7616  llrp_utf8v_t m_RMCSentence;
7617 
7620  public:
7621  static const CFieldDescriptor
7622  s_fdRMCSentence;
7624 
7626  inline llrp_utf8v_t
7628  {
7629  return m_RMCSentence;
7630  }
7631 
7633  inline void
7635  llrp_utf8v_t value)
7636  {
7637  m_RMCSentence = value;
7638  }
7639 
7640 
7641 
7642  protected:
7643  std::list<CParameter *> m_listCustom;
7644 
7645  public:
7647  inline std::list<CParameter *>::iterator
7649  {
7650  return m_listCustom.begin();
7651  }
7652 
7654  inline std::list<CParameter *>::iterator
7655  endCustom (void)
7656  {
7657  return m_listCustom.end();
7658  }
7659 
7661  inline void
7663  {
7664  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7665  }
7666 
7668  inline int
7670  {
7671  return (int) (m_listCustom.size());
7672  }
7673 
7674  EResultCode
7676  addCustom (
7677  CParameter * pValue);
7678 
7679 
7680 };
7681 
7682 
7706 class CImpinjOpSpecRetryCount : public CParameter
7707 {
7708  public:
7709  CImpinjOpSpecRetryCount (void);
7710  ~CImpinjOpSpecRetryCount (void);
7711 
7714 
7715  static const CFieldDescriptor * const
7716  s_apFieldDescriptorTable[];
7717 
7718  static const CTypeDescriptor
7719  s_typeDescriptor;
7720 
7721  void
7722  decodeFields (
7723  CDecoderStream * pDecoderStream);
7724 
7725  void
7726  assimilateSubParameters (
7727  CErrorDetails * pError);
7728 
7729  void
7730  encode (
7731  CEncoderStream * pEncoderStream) const;
7732 
7733 
7734  llrp_bool_t
7735  isAllowedIn (
7736  const CTypeDescriptor * pEnclosingElementType) const;
7737 
7738 
7739  static CElement *
7740  s_construct (void);
7741 
7742  static void
7743  s_decodeFields (
7744  CDecoderStream * pDecoderStream,
7745  CElement * pElement);
7747 
7748 
7749  protected:
7750  llrp_u16_t m_RetryCount;
7751 
7754  public:
7755  static const CFieldDescriptor
7756  s_fdRetryCount;
7758 
7760  inline llrp_u16_t
7762  {
7763  return m_RetryCount;
7764  }
7765 
7767  inline void
7769  llrp_u16_t value)
7770  {
7771  m_RetryCount = value;
7772  }
7773 
7774 
7775 
7776  protected:
7777  std::list<CParameter *> m_listCustom;
7778 
7779  public:
7781  inline std::list<CParameter *>::iterator
7783  {
7784  return m_listCustom.begin();
7785  }
7786 
7788  inline std::list<CParameter *>::iterator
7789  endCustom (void)
7790  {
7791  return m_listCustom.end();
7792  }
7793 
7795  inline void
7797  {
7798  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7799  }
7800 
7802  inline int
7804  {
7805  return (int) (m_listCustom.size());
7806  }
7807 
7808  EResultCode
7810  addCustom (
7811  CParameter * pValue);
7812 
7813 
7814 };
7815 
7816 
7844 class CImpinjAdvancedGPOConfiguration : public CParameter
7845 {
7846  public:
7849 
7852 
7853  static const CFieldDescriptor * const
7854  s_apFieldDescriptorTable[];
7855 
7856  static const CTypeDescriptor
7857  s_typeDescriptor;
7858 
7859  void
7860  decodeFields (
7861  CDecoderStream * pDecoderStream);
7862 
7863  void
7864  assimilateSubParameters (
7865  CErrorDetails * pError);
7866 
7867  void
7868  encode (
7869  CEncoderStream * pEncoderStream) const;
7870 
7871 
7872  llrp_bool_t
7873  isAllowedIn (
7874  const CTypeDescriptor * pEnclosingElementType) const;
7875 
7876 
7877  static CElement *
7878  s_construct (void);
7879 
7880  static void
7881  s_decodeFields (
7882  CDecoderStream * pDecoderStream,
7883  CElement * pElement);
7885 
7886 
7887  protected:
7888  llrp_u16_t m_GPOPortNum;
7889 
7892  public:
7893  static const CFieldDescriptor
7894  s_fdGPOPortNum;
7896 
7898  inline llrp_u16_t
7900  {
7901  return m_GPOPortNum;
7902  }
7903 
7905  inline void
7907  llrp_u16_t value)
7908  {
7909  m_GPOPortNum = value;
7910  }
7911 
7912 
7913  protected:
7914  EImpinjAdvancedGPOMode m_eGPOMode;
7915 
7918  public:
7919  static const CFieldDescriptor
7920  s_fdGPOMode;
7922 
7924  inline EImpinjAdvancedGPOMode
7925  getGPOMode (void)
7926  {
7927  return m_eGPOMode;
7928  }
7929 
7931  inline void
7933  EImpinjAdvancedGPOMode value)
7934  {
7935  m_eGPOMode = value;
7936  }
7937 
7938 
7939  protected:
7940  llrp_u32_t m_GPOPulseDurationMSec;
7941 
7944  public:
7945  static const CFieldDescriptor
7946  s_fdGPOPulseDurationMSec;
7948 
7950  inline llrp_u32_t
7952  {
7953  return m_GPOPulseDurationMSec;
7954  }
7955 
7957  inline void
7959  llrp_u32_t value)
7960  {
7961  m_GPOPulseDurationMSec = value;
7962  }
7963 
7964 
7965 
7966  protected:
7967  std::list<CParameter *> m_listCustom;
7968 
7969  public:
7971  inline std::list<CParameter *>::iterator
7973  {
7974  return m_listCustom.begin();
7975  }
7976 
7978  inline std::list<CParameter *>::iterator
7979  endCustom (void)
7980  {
7981  return m_listCustom.end();
7982  }
7983 
7985  inline void
7987  {
7988  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7989  }
7990 
7992  inline int
7994  {
7995  return (int) (m_listCustom.size());
7996  }
7997 
7998  EResultCode
8000  addCustom (
8001  CParameter * pValue);
8002 
8003 
8004 };
8005 
8006 
8040 class CImpinjEnableOptimizedRead : public CParameter
8041 {
8042  public:
8045 
8048 
8049  static const CFieldDescriptor * const
8050  s_apFieldDescriptorTable[];
8051 
8052  static const CTypeDescriptor
8053  s_typeDescriptor;
8054 
8055  void
8056  decodeFields (
8057  CDecoderStream * pDecoderStream);
8058 
8059  void
8060  assimilateSubParameters (
8061  CErrorDetails * pError);
8062 
8063  void
8064  encode (
8065  CEncoderStream * pEncoderStream) const;
8066 
8067 
8068  llrp_bool_t
8069  isAllowedIn (
8070  const CTypeDescriptor * pEnclosingElementType) const;
8071 
8072 
8073  static CElement *
8074  s_construct (void);
8075 
8076  static void
8077  s_decodeFields (
8078  CDecoderStream * pDecoderStream,
8079  CElement * pElement);
8081 
8082 
8083  protected:
8084  EImpinjOptimizedReadMode m_eOptimizedReadMode;
8085 
8088  public:
8089  static const CFieldDescriptor
8090  s_fdOptimizedReadMode;
8092 
8094  inline EImpinjOptimizedReadMode
8096  {
8097  return m_eOptimizedReadMode;
8098  }
8099 
8101  inline void
8103  EImpinjOptimizedReadMode value)
8104  {
8105  m_eOptimizedReadMode = value;
8106  }
8107 
8108 
8109 
8110  protected:
8111  std::list<CC1G2Read *> m_listC1G2Read;
8112 
8113  public:
8115  inline std::list<CC1G2Read *>::iterator
8117  {
8118  return m_listC1G2Read.begin();
8119  }
8120 
8122  inline std::list<CC1G2Read *>::iterator
8124  {
8125  return m_listC1G2Read.end();
8126  }
8127 
8129  inline void
8131  {
8132  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
8133  }
8134 
8136  inline int
8138  {
8139  return (int) (m_listC1G2Read.size());
8140  }
8141 
8142  EResultCode
8144  addC1G2Read (
8145  CC1G2Read * pValue);
8146 
8147 
8148  protected:
8149  std::list<CParameter *> m_listCustom;
8150 
8151  public:
8153  inline std::list<CParameter *>::iterator
8155  {
8156  return m_listCustom.begin();
8157  }
8158 
8160  inline std::list<CParameter *>::iterator
8161  endCustom (void)
8162  {
8163  return m_listCustom.end();
8164  }
8165 
8167  inline void
8169  {
8170  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8171  }
8172 
8174  inline int
8176  {
8177  return (int) (m_listCustom.size());
8178  }
8179 
8180  EResultCode
8182  addCustom (
8183  CParameter * pValue);
8184 
8185 
8186 };
8187 
8188 
8215 class CImpinjAccessSpecOrdering : public CParameter
8216 {
8217  public:
8219  ~CImpinjAccessSpecOrdering (void);
8220 
8223 
8224  static const CFieldDescriptor * const
8225  s_apFieldDescriptorTable[];
8226 
8227  static const CTypeDescriptor
8228  s_typeDescriptor;
8229 
8230  void
8231  decodeFields (
8232  CDecoderStream * pDecoderStream);
8233 
8234  void
8235  assimilateSubParameters (
8236  CErrorDetails * pError);
8237 
8238  void
8239  encode (
8240  CEncoderStream * pEncoderStream) const;
8241 
8242 
8243  llrp_bool_t
8244  isAllowedIn (
8245  const CTypeDescriptor * pEnclosingElementType) const;
8246 
8247 
8248  static CElement *
8249  s_construct (void);
8250 
8251  static void
8252  s_decodeFields (
8253  CDecoderStream * pDecoderStream,
8254  CElement * pElement);
8256 
8257 
8258  protected:
8259  EImpinjAccessSpecOrderingMode m_eOrderingMode;
8260 
8263  public:
8264  static const CFieldDescriptor
8265  s_fdOrderingMode;
8267 
8269  inline EImpinjAccessSpecOrderingMode
8271  {
8272  return m_eOrderingMode;
8273  }
8274 
8276  inline void
8278  EImpinjAccessSpecOrderingMode value)
8279  {
8280  m_eOrderingMode = value;
8281  }
8282 
8283 
8284 
8285  protected:
8286  std::list<CParameter *> m_listCustom;
8287 
8288  public:
8290  inline std::list<CParameter *>::iterator
8292  {
8293  return m_listCustom.begin();
8294  }
8295 
8297  inline std::list<CParameter *>::iterator
8298  endCustom (void)
8299  {
8300  return m_listCustom.end();
8301  }
8302 
8304  inline void
8306  {
8307  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8308  }
8309 
8311  inline int
8313  {
8314  return (int) (m_listCustom.size());
8315  }
8316 
8317  EResultCode
8319  addCustom (
8320  CParameter * pValue);
8321 
8322 
8323 };
8324 
8325 
8349 class CImpinjEnableRFDopplerFrequency : public CParameter
8350 {
8351  public:
8354 
8357 
8358  static const CFieldDescriptor * const
8359  s_apFieldDescriptorTable[];
8360 
8361  static const CTypeDescriptor
8362  s_typeDescriptor;
8363 
8364  void
8365  decodeFields (
8366  CDecoderStream * pDecoderStream);
8367 
8368  void
8369  assimilateSubParameters (
8370  CErrorDetails * pError);
8371 
8372  void
8373  encode (
8374  CEncoderStream * pEncoderStream) const;
8375 
8376 
8377  llrp_bool_t
8378  isAllowedIn (
8379  const CTypeDescriptor * pEnclosingElementType) const;
8380 
8381 
8382  static CElement *
8383  s_construct (void);
8384 
8385  static void
8386  s_decodeFields (
8387  CDecoderStream * pDecoderStream,
8388  CElement * pElement);
8390 
8391 
8392  protected:
8393  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8394 
8397  public:
8398  static const CFieldDescriptor
8399  s_fdRFDopplerFrequencyMode;
8401 
8403  inline EImpinjRFDopplerFrequencyMode
8405  {
8406  return m_eRFDopplerFrequencyMode;
8407  }
8408 
8410  inline void
8412  EImpinjRFDopplerFrequencyMode value)
8413  {
8414  m_eRFDopplerFrequencyMode = value;
8415  }
8416 
8417 
8418 
8419  protected:
8420  std::list<CParameter *> m_listCustom;
8421 
8422  public:
8424  inline std::list<CParameter *>::iterator
8426  {
8427  return m_listCustom.begin();
8428  }
8429 
8431  inline std::list<CParameter *>::iterator
8432  endCustom (void)
8433  {
8434  return m_listCustom.end();
8435  }
8436 
8438  inline void
8440  {
8441  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8442  }
8443 
8445  inline int
8447  {
8448  return (int) (m_listCustom.size());
8449  }
8450 
8451  EResultCode
8453  addCustom (
8454  CParameter * pValue);
8455 
8456 
8457 };
8458 
8459 
8484 class CImpinjRFDopplerFrequency : public CParameter
8485 {
8486  public:
8488  ~CImpinjRFDopplerFrequency (void);
8489 
8492 
8493  static const CFieldDescriptor * const
8494  s_apFieldDescriptorTable[];
8495 
8496  static const CTypeDescriptor
8497  s_typeDescriptor;
8498 
8499  void
8500  decodeFields (
8501  CDecoderStream * pDecoderStream);
8502 
8503  void
8504  assimilateSubParameters (
8505  CErrorDetails * pError);
8506 
8507  void
8508  encode (
8509  CEncoderStream * pEncoderStream) const;
8510 
8511 
8512  llrp_bool_t
8513  isAllowedIn (
8514  const CTypeDescriptor * pEnclosingElementType) const;
8515 
8516 
8517  static CElement *
8518  s_construct (void);
8519 
8520  static void
8521  s_decodeFields (
8522  CDecoderStream * pDecoderStream,
8523  CElement * pElement);
8525 
8526 
8527  protected:
8528  llrp_s16_t m_DopplerFrequency;
8529 
8532  public:
8533  static const CFieldDescriptor
8534  s_fdDopplerFrequency;
8536 
8538  inline llrp_s16_t
8540  {
8541  return m_DopplerFrequency;
8542  }
8543 
8545  inline void
8547  llrp_s16_t value)
8548  {
8549  m_DopplerFrequency = value;
8550  }
8551 
8552 
8553 
8554  protected:
8555  std::list<CParameter *> m_listCustom;
8556 
8557  public:
8559  inline std::list<CParameter *>::iterator
8561  {
8562  return m_listCustom.begin();
8563  }
8564 
8566  inline std::list<CParameter *>::iterator
8567  endCustom (void)
8568  {
8569  return m_listCustom.end();
8570  }
8571 
8573  inline void
8575  {
8576  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8577  }
8578 
8580  inline int
8582  {
8583  return (int) (m_listCustom.size());
8584  }
8585 
8586  EResultCode
8588  addCustom (
8589  CParameter * pValue);
8590 
8591 
8592 };
8593 
8594 
8627 class CImpinjInventoryConfiguration : public CParameter
8628 {
8629  public:
8632 
8635 
8636  static const CFieldDescriptor * const
8637  s_apFieldDescriptorTable[];
8638 
8639  static const CTypeDescriptor
8640  s_typeDescriptor;
8641 
8642  void
8643  decodeFields (
8644  CDecoderStream * pDecoderStream);
8645 
8646  void
8647  assimilateSubParameters (
8648  CErrorDetails * pError);
8649 
8650  void
8651  encode (
8652  CEncoderStream * pEncoderStream) const;
8653 
8654 
8655  llrp_bool_t
8656  isAllowedIn (
8657  const CTypeDescriptor * pEnclosingElementType) const;
8658 
8659 
8660  static CElement *
8661  s_construct (void);
8662 
8663  static void
8664  s_decodeFields (
8665  CDecoderStream * pDecoderStream,
8666  CElement * pElement);
8668 
8669 
8670  protected:
8671  llrp_u1_t m_EnableAntDwellTimeLimit;
8672 
8675  public:
8676  static const CFieldDescriptor
8677  s_fdEnableAntDwellTimeLimit;
8679 
8681  inline llrp_u1_t
8683  {
8684  return m_EnableAntDwellTimeLimit;
8685  }
8686 
8688  inline void
8690  llrp_u1_t value)
8691  {
8692  m_EnableAntDwellTimeLimit = value;
8693  }
8694 
8695 
8696  protected:
8697  llrp_u1_t m_EnableSelectGapClose;
8698 
8701  public:
8702  static const CFieldDescriptor
8703  s_fdEnableSelectGapClose;
8705 
8707  inline llrp_u1_t
8709  {
8710  return m_EnableSelectGapClose;
8711  }
8712 
8714  inline void
8716  llrp_u1_t value)
8717  {
8718  m_EnableSelectGapClose = value;
8719  }
8720 
8721 
8722 
8723  protected:
8724  std::list<CParameter *> m_listCustom;
8725 
8726  public:
8728  inline std::list<CParameter *>::iterator
8730  {
8731  return m_listCustom.begin();
8732  }
8733 
8735  inline std::list<CParameter *>::iterator
8736  endCustom (void)
8737  {
8738  return m_listCustom.end();
8739  }
8740 
8742  inline void
8744  {
8745  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8746  }
8747 
8749  inline int
8751  {
8752  return (int) (m_listCustom.size());
8753  }
8754 
8755  EResultCode
8757  addCustom (
8758  CParameter * pValue);
8759 
8760 
8761 };
8762 
8763 
8787 class CImpinjEnableTxPower : public CParameter
8788 {
8789  public:
8790  CImpinjEnableTxPower (void);
8791  ~CImpinjEnableTxPower (void);
8792 
8795 
8796  static const CFieldDescriptor * const
8797  s_apFieldDescriptorTable[];
8798 
8799  static const CTypeDescriptor
8800  s_typeDescriptor;
8801 
8802  void
8803  decodeFields (
8804  CDecoderStream * pDecoderStream);
8805 
8806  void
8807  assimilateSubParameters (
8808  CErrorDetails * pError);
8809 
8810  void
8811  encode (
8812  CEncoderStream * pEncoderStream) const;
8813 
8814 
8815  llrp_bool_t
8816  isAllowedIn (
8817  const CTypeDescriptor * pEnclosingElementType) const;
8818 
8819 
8820  static CElement *
8821  s_construct (void);
8822 
8823  static void
8824  s_decodeFields (
8825  CDecoderStream * pDecoderStream,
8826  CElement * pElement);
8828 
8829 
8830  protected:
8831  EImpinjTxPowerReportingModeEnum m_eTxPowerReportingMode;
8832 
8835  public:
8836  static const CFieldDescriptor
8837  s_fdTxPowerReportingMode;
8839 
8841  inline EImpinjTxPowerReportingModeEnum
8843  {
8844  return m_eTxPowerReportingMode;
8845  }
8846 
8848  inline void
8850  EImpinjTxPowerReportingModeEnum value)
8851  {
8852  m_eTxPowerReportingMode = value;
8853  }
8854 
8855 
8856 
8857  protected:
8858  std::list<CParameter *> m_listCustom;
8859 
8860  public:
8862  inline std::list<CParameter *>::iterator
8864  {
8865  return m_listCustom.begin();
8866  }
8867 
8869  inline std::list<CParameter *>::iterator
8870  endCustom (void)
8871  {
8872  return m_listCustom.end();
8873  }
8874 
8876  inline void
8878  {
8879  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8880  }
8881 
8883  inline int
8885  {
8886  return (int) (m_listCustom.size());
8887  }
8888 
8889  EResultCode
8891  addCustom (
8892  CParameter * pValue);
8893 
8894 
8895 };
8896 
8897 
8922 class CImpinjTxPower : public CParameter
8923 {
8924  public:
8925  CImpinjTxPower (void);
8926  ~CImpinjTxPower (void);
8927 
8930 
8931  static const CFieldDescriptor * const
8932  s_apFieldDescriptorTable[];
8933 
8934  static const CTypeDescriptor
8935  s_typeDescriptor;
8936 
8937  void
8938  decodeFields (
8939  CDecoderStream * pDecoderStream);
8940 
8941  void
8942  assimilateSubParameters (
8943  CErrorDetails * pError);
8944 
8945  void
8946  encode (
8947  CEncoderStream * pEncoderStream) const;
8948 
8949 
8950  llrp_bool_t
8951  isAllowedIn (
8952  const CTypeDescriptor * pEnclosingElementType) const;
8953 
8954 
8955  static CElement *
8956  s_construct (void);
8957 
8958  static void
8959  s_decodeFields (
8960  CDecoderStream * pDecoderStream,
8961  CElement * pElement);
8963 
8964 
8965  protected:
8966  llrp_u16_t m_TxPower;
8967 
8970  public:
8971  static const CFieldDescriptor
8972  s_fdTxPower;
8974 
8976  inline llrp_u16_t
8977  getTxPower (void)
8978  {
8979  return m_TxPower;
8980  }
8981 
8983  inline void
8985  llrp_u16_t value)
8986  {
8987  m_TxPower = value;
8988  }
8989 
8990 
8991 
8992  protected:
8993  std::list<CParameter *> m_listCustom;
8994 
8995  public:
8997  inline std::list<CParameter *>::iterator
8999  {
9000  return m_listCustom.begin();
9001  }
9002 
9004  inline std::list<CParameter *>::iterator
9005  endCustom (void)
9006  {
9007  return m_listCustom.end();
9008  }
9009 
9011  inline void
9013  {
9014  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9015  }
9016 
9018  inline int
9020  {
9021  return (int) (m_listCustom.size());
9022  }
9023 
9024  EResultCode
9026  addCustom (
9027  CParameter * pValue);
9028 
9029 
9030 };
9031 
9032 
9059 class CImpinjArrayVersion : public CParameter
9060 {
9061  public:
9062  CImpinjArrayVersion (void);
9063  ~CImpinjArrayVersion (void);
9064 
9067 
9068  static const CFieldDescriptor * const
9069  s_apFieldDescriptorTable[];
9070 
9071  static const CTypeDescriptor
9072  s_typeDescriptor;
9073 
9074  void
9075  decodeFields (
9076  CDecoderStream * pDecoderStream);
9077 
9078  void
9079  assimilateSubParameters (
9080  CErrorDetails * pError);
9081 
9082  void
9083  encode (
9084  CEncoderStream * pEncoderStream) const;
9085 
9086 
9087  llrp_bool_t
9088  isAllowedIn (
9089  const CTypeDescriptor * pEnclosingElementType) const;
9090 
9091 
9092  static CElement *
9093  s_construct (void);
9094 
9095  static void
9096  s_decodeFields (
9097  CDecoderStream * pDecoderStream,
9098  CElement * pElement);
9100 
9101 
9102  protected:
9103  llrp_utf8v_t m_SerialNumber;
9104 
9107  public:
9108  static const CFieldDescriptor
9109  s_fdSerialNumber;
9111 
9113  inline llrp_utf8v_t
9115  {
9116  return m_SerialNumber;
9117  }
9118 
9120  inline void
9122  llrp_utf8v_t value)
9123  {
9124  m_SerialNumber = value;
9125  }
9126 
9127 
9128  protected:
9129  llrp_utf8v_t m_FirmwareVersion;
9130 
9133  public:
9134  static const CFieldDescriptor
9135  s_fdFirmwareVersion;
9137 
9139  inline llrp_utf8v_t
9141  {
9142  return m_FirmwareVersion;
9143  }
9144 
9146  inline void
9148  llrp_utf8v_t value)
9149  {
9150  m_FirmwareVersion = value;
9151  }
9152 
9153 
9154  protected:
9155  llrp_utf8v_t m_PCBAVersion;
9156 
9159  public:
9160  static const CFieldDescriptor
9161  s_fdPCBAVersion;
9163 
9165  inline llrp_utf8v_t
9167  {
9168  return m_PCBAVersion;
9169  }
9170 
9172  inline void
9174  llrp_utf8v_t value)
9175  {
9176  m_PCBAVersion = value;
9177  }
9178 
9179 
9180 
9181  protected:
9182  std::list<CParameter *> m_listCustom;
9183 
9184  public:
9186  inline std::list<CParameter *>::iterator
9188  {
9189  return m_listCustom.begin();
9190  }
9191 
9193  inline std::list<CParameter *>::iterator
9194  endCustom (void)
9195  {
9196  return m_listCustom.end();
9197  }
9198 
9200  inline void
9202  {
9203  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9204  }
9205 
9207  inline int
9209  {
9210  return (int) (m_listCustom.size());
9211  }
9212 
9213  EResultCode
9215  addCustom (
9216  CParameter * pValue);
9217 
9218 
9219 };
9220 
9221 
9254 class CImpinjxArrayCapabilities : public CParameter
9255 {
9256  public:
9258  ~CImpinjxArrayCapabilities (void);
9259 
9262 
9263  static const CFieldDescriptor * const
9264  s_apFieldDescriptorTable[];
9265 
9266  static const CTypeDescriptor
9267  s_typeDescriptor;
9268 
9269  void
9270  decodeFields (
9271  CDecoderStream * pDecoderStream);
9272 
9273  void
9274  assimilateSubParameters (
9275  CErrorDetails * pError);
9276 
9277  void
9278  encode (
9279  CEncoderStream * pEncoderStream) const;
9280 
9281 
9282  llrp_bool_t
9283  isAllowedIn (
9284  const CTypeDescriptor * pEnclosingElementType) const;
9285 
9286 
9287  static CElement *
9288  s_construct (void);
9289 
9290  static void
9291  s_decodeFields (
9292  CDecoderStream * pDecoderStream,
9293  CElement * pElement);
9295 
9296 
9297  protected:
9298  llrp_u32_t m_MaxNumSectors;
9299 
9302  public:
9303  static const CFieldDescriptor
9304  s_fdMaxNumSectors;
9306 
9308  inline llrp_u32_t
9310  {
9311  return m_MaxNumSectors;
9312  }
9313 
9315  inline void
9317  llrp_u32_t value)
9318  {
9319  m_MaxNumSectors = value;
9320  }
9321 
9322 
9323  protected:
9324  llrp_u1_t m_SupportsLISpecs;
9325 
9328  public:
9329  static const CFieldDescriptor
9330  s_fdSupportsLISpecs;
9332 
9334  inline llrp_u1_t
9336  {
9337  return m_SupportsLISpecs;
9338  }
9339 
9341  inline void
9343  llrp_u1_t value)
9344  {
9345  m_SupportsLISpecs = value;
9346  }
9347 
9348 
9349  protected:
9350  llrp_u1_t m_SupportsTISpecs;
9351 
9354  public:
9355  static const CFieldDescriptor
9356  s_fdSupportsTISpecs;
9358 
9360  inline llrp_u1_t
9362  {
9363  return m_SupportsTISpecs;
9364  }
9365 
9367  inline void
9369  llrp_u1_t value)
9370  {
9371  m_SupportsTISpecs = value;
9372  }
9373 
9374 
9375  protected:
9376  llrp_u1_t m_SupportsTSISpecs;
9377 
9380  public:
9381  static const CFieldDescriptor
9382  s_fdSupportsTSISpecs;
9384 
9386  inline llrp_u1_t
9388  {
9389  return m_SupportsTSISpecs;
9390  }
9391 
9393  inline void
9395  llrp_u1_t value)
9396  {
9397  m_SupportsTSISpecs = value;
9398  }
9399 
9400 
9401  protected:
9402  llrp_u1_t m_SupportsDISpecs;
9403 
9406  public:
9407  static const CFieldDescriptor
9408  s_fdSupportsDISpecs;
9410 
9412  inline llrp_u1_t
9414  {
9415  return m_SupportsDISpecs;
9416  }
9417 
9419  inline void
9421  llrp_u1_t value)
9422  {
9423  m_SupportsDISpecs = value;
9424  }
9425 
9426 
9427 
9428  protected:
9429  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
9430 
9431  public:
9435  {
9436  return m_pImpinjxArrayDirectionCapabilities;
9437  }
9438 
9440  EResultCode
9441  setImpinjxArrayDirectionCapabilities (
9443 
9444 
9445  protected:
9446  std::list<CParameter *> m_listCustom;
9447 
9448  public:
9450  inline std::list<CParameter *>::iterator
9452  {
9453  return m_listCustom.begin();
9454  }
9455 
9457  inline std::list<CParameter *>::iterator
9458  endCustom (void)
9459  {
9460  return m_listCustom.end();
9461  }
9462 
9464  inline void
9466  {
9467  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9468  }
9469 
9471  inline int
9473  {
9474  return (int) (m_listCustom.size());
9475  }
9476 
9477  EResultCode
9479  addCustom (
9480  CParameter * pValue);
9481 
9482 
9483 };
9484 
9485 
9513 class CImpinjTiltConfiguration : public CParameter
9514 {
9515  public:
9516  CImpinjTiltConfiguration (void);
9517  ~CImpinjTiltConfiguration (void);
9518 
9521 
9522  static const CFieldDescriptor * const
9523  s_apFieldDescriptorTable[];
9524 
9525  static const CTypeDescriptor
9526  s_typeDescriptor;
9527 
9528  void
9529  decodeFields (
9530  CDecoderStream * pDecoderStream);
9531 
9532  void
9533  assimilateSubParameters (
9534  CErrorDetails * pError);
9535 
9536  void
9537  encode (
9538  CEncoderStream * pEncoderStream) const;
9539 
9540 
9541  llrp_bool_t
9542  isAllowedIn (
9543  const CTypeDescriptor * pEnclosingElementType) const;
9544 
9545 
9546  static CElement *
9547  s_construct (void);
9548 
9549  static void
9550  s_decodeFields (
9551  CDecoderStream * pDecoderStream,
9552  CElement * pElement);
9554 
9555 
9556  protected:
9557  llrp_s32_t m_XAxis;
9558 
9561  public:
9562  static const CFieldDescriptor
9563  s_fdXAxis;
9565 
9567  inline llrp_s32_t
9568  getXAxis (void)
9569  {
9570  return m_XAxis;
9571  }
9572 
9574  inline void
9576  llrp_s32_t value)
9577  {
9578  m_XAxis = value;
9579  }
9580 
9581 
9582  protected:
9583  llrp_s32_t m_YAxis;
9584 
9587  public:
9588  static const CFieldDescriptor
9589  s_fdYAxis;
9591 
9593  inline llrp_s32_t
9594  getYAxis (void)
9595  {
9596  return m_YAxis;
9597  }
9598 
9600  inline void
9602  llrp_s32_t value)
9603  {
9604  m_YAxis = value;
9605  }
9606 
9607 
9608  protected:
9609  llrp_s32_t m_ZAxis;
9610 
9613  public:
9614  static const CFieldDescriptor
9615  s_fdZAxis;
9617 
9619  inline llrp_s32_t
9620  getZAxis (void)
9621  {
9622  return m_ZAxis;
9623  }
9624 
9626  inline void
9628  llrp_s32_t value)
9629  {
9630  m_ZAxis = value;
9631  }
9632 
9633 
9634 
9635  protected:
9636  std::list<CParameter *> m_listCustom;
9637 
9638  public:
9640  inline std::list<CParameter *>::iterator
9642  {
9643  return m_listCustom.begin();
9644  }
9645 
9647  inline std::list<CParameter *>::iterator
9648  endCustom (void)
9649  {
9650  return m_listCustom.end();
9651  }
9652 
9654  inline void
9656  {
9657  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9658  }
9659 
9661  inline int
9663  {
9664  return (int) (m_listCustom.size());
9665  }
9666 
9667  EResultCode
9669  addCustom (
9670  CParameter * pValue);
9671 
9672 
9673 };
9674 
9675 
9704 class CImpinjBeaconConfiguration : public CParameter
9705 {
9706  public:
9709 
9712 
9713  static const CFieldDescriptor * const
9714  s_apFieldDescriptorTable[];
9715 
9716  static const CTypeDescriptor
9717  s_typeDescriptor;
9718 
9719  void
9720  decodeFields (
9721  CDecoderStream * pDecoderStream);
9722 
9723  void
9724  assimilateSubParameters (
9725  CErrorDetails * pError);
9726 
9727  void
9728  encode (
9729  CEncoderStream * pEncoderStream) const;
9730 
9731 
9732  llrp_bool_t
9733  isAllowedIn (
9734  const CTypeDescriptor * pEnclosingElementType) const;
9735 
9736 
9737  static CElement *
9738  s_construct (void);
9739 
9740  static void
9741  s_decodeFields (
9742  CDecoderStream * pDecoderStream,
9743  CElement * pElement);
9745 
9746 
9747  protected:
9748  llrp_u1_t m_BeaconState;
9749 
9752  public:
9753  static const CFieldDescriptor
9754  s_fdBeaconState;
9756 
9758  inline llrp_u1_t
9760  {
9761  return m_BeaconState;
9762  }
9763 
9765  inline void
9767  llrp_u1_t value)
9768  {
9769  m_BeaconState = value;
9770  }
9771 
9772 
9773  protected:
9774  llrp_u64_t m_BeaconDurationSeconds;
9775 
9778  public:
9779  static const CFieldDescriptor
9780  s_fdBeaconDurationSeconds;
9782 
9784  inline llrp_u64_t
9786  {
9787  return m_BeaconDurationSeconds;
9788  }
9789 
9791  inline void
9793  llrp_u64_t value)
9794  {
9795  m_BeaconDurationSeconds = value;
9796  }
9797 
9798 
9799 
9800  protected:
9801  std::list<CParameter *> m_listCustom;
9802 
9803  public:
9805  inline std::list<CParameter *>::iterator
9807  {
9808  return m_listCustom.begin();
9809  }
9810 
9812  inline std::list<CParameter *>::iterator
9813  endCustom (void)
9814  {
9815  return m_listCustom.end();
9816  }
9817 
9819  inline void
9821  {
9822  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9823  }
9824 
9826  inline int
9828  {
9829  return (int) (m_listCustom.size());
9830  }
9831 
9832  EResultCode
9834  addCustom (
9835  CParameter * pValue);
9836 
9837 
9838 };
9839 
9840 
9868 class CImpinjAntennaConfiguration : public CParameter
9869 {
9870  public:
9873 
9876 
9877  static const CFieldDescriptor * const
9878  s_apFieldDescriptorTable[];
9879 
9880  static const CTypeDescriptor
9881  s_typeDescriptor;
9882 
9883  void
9884  decodeFields (
9885  CDecoderStream * pDecoderStream);
9886 
9887  void
9888  assimilateSubParameters (
9889  CErrorDetails * pError);
9890 
9891  void
9892  encode (
9893  CEncoderStream * pEncoderStream) const;
9894 
9895 
9896  llrp_bool_t
9897  isAllowedIn (
9898  const CTypeDescriptor * pEnclosingElementType) const;
9899 
9900 
9901  static CElement *
9902  s_construct (void);
9903 
9904  static void
9905  s_decodeFields (
9906  CDecoderStream * pDecoderStream,
9907  CElement * pElement);
9909 
9910 
9911 
9912  protected:
9913  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9914 
9915  public:
9919  {
9920  return m_pImpinjAntennaEventHysteresis;
9921  }
9922 
9924  EResultCode
9925  setImpinjAntennaEventHysteresis (
9927 
9928 
9929  protected:
9930  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9931 
9932  public:
9936  {
9937  return m_pImpinjAntennaEventConfiguration;
9938  }
9939 
9941  EResultCode
9942  setImpinjAntennaEventConfiguration (
9944 
9945 
9946  protected:
9947  std::list<CParameter *> m_listCustom;
9948 
9949  public:
9951  inline std::list<CParameter *>::iterator
9953  {
9954  return m_listCustom.begin();
9955  }
9956 
9958  inline std::list<CParameter *>::iterator
9959  endCustom (void)
9960  {
9961  return m_listCustom.end();
9962  }
9963 
9965  inline void
9967  {
9968  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9969  }
9970 
9972  inline int
9974  {
9975  return (int) (m_listCustom.size());
9976  }
9977 
9978  EResultCode
9980  addCustom (
9981  CParameter * pValue);
9982 
9983 
9984 };
9985 
9986 
10018 class CImpinjAntennaEventHysteresis : public CParameter
10019 {
10020  public:
10023 
10026 
10027  static const CFieldDescriptor * const
10028  s_apFieldDescriptorTable[];
10029 
10030  static const CTypeDescriptor
10031  s_typeDescriptor;
10032 
10033  void
10034  decodeFields (
10035  CDecoderStream * pDecoderStream);
10036 
10037  void
10038  assimilateSubParameters (
10039  CErrorDetails * pError);
10040 
10041  void
10042  encode (
10043  CEncoderStream * pEncoderStream) const;
10044 
10045 
10046  llrp_bool_t
10047  isAllowedIn (
10048  const CTypeDescriptor * pEnclosingElementType) const;
10049 
10050 
10051  static CElement *
10052  s_construct (void);
10053 
10054  static void
10055  s_decodeFields (
10056  CDecoderStream * pDecoderStream,
10057  CElement * pElement);
10059 
10060 
10061  protected:
10062  llrp_u64_t m_AntennaEventConnected;
10063 
10066  public:
10067  static const CFieldDescriptor
10068  s_fdAntennaEventConnected;
10070 
10072  inline llrp_u64_t
10074  {
10075  return m_AntennaEventConnected;
10076  }
10077 
10079  inline void
10081  llrp_u64_t value)
10082  {
10083  m_AntennaEventConnected = value;
10084  }
10085 
10086 
10087  protected:
10088  llrp_u64_t m_AntennaEventDisconnected;
10089 
10092  public:
10093  static const CFieldDescriptor
10094  s_fdAntennaEventDisconnected;
10096 
10098  inline llrp_u64_t
10100  {
10101  return m_AntennaEventDisconnected;
10102  }
10103 
10105  inline void
10107  llrp_u64_t value)
10108  {
10109  m_AntennaEventDisconnected = value;
10110  }
10111 
10112 
10113 
10114  protected:
10115  std::list<CParameter *> m_listCustom;
10116 
10117  public:
10119  inline std::list<CParameter *>::iterator
10121  {
10122  return m_listCustom.begin();
10123  }
10124 
10126  inline std::list<CParameter *>::iterator
10127  endCustom (void)
10128  {
10129  return m_listCustom.end();
10130  }
10131 
10133  inline void
10135  {
10136  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10137  }
10138 
10140  inline int
10142  {
10143  return (int) (m_listCustom.size());
10144  }
10145 
10146  EResultCode
10148  addCustom (
10149  CParameter * pValue);
10150 
10151 
10152 };
10153 
10154 
10180 class CImpinjAntennaEventConfiguration : public CParameter
10181 {
10182  public:
10185 
10188 
10189  static const CFieldDescriptor * const
10190  s_apFieldDescriptorTable[];
10191 
10192  static const CTypeDescriptor
10193  s_typeDescriptor;
10194 
10195  void
10196  decodeFields (
10197  CDecoderStream * pDecoderStream);
10198 
10199  void
10200  assimilateSubParameters (
10201  CErrorDetails * pError);
10202 
10203  void
10204  encode (
10205  CEncoderStream * pEncoderStream) const;
10206 
10207 
10208  llrp_bool_t
10209  isAllowedIn (
10210  const CTypeDescriptor * pEnclosingElementType) const;
10211 
10212 
10213  static CElement *
10214  s_construct (void);
10215 
10216  static void
10217  s_decodeFields (
10218  CDecoderStream * pDecoderStream,
10219  CElement * pElement);
10221 
10222 
10223  protected:
10224  llrp_u1_t m_EnableAntennaAttemptNotification;
10225 
10228  public:
10229  static const CFieldDescriptor
10230  s_fdEnableAntennaAttemptNotification;
10232 
10234  inline llrp_u1_t
10236  {
10237  return m_EnableAntennaAttemptNotification;
10238  }
10239 
10241  inline void
10243  llrp_u1_t value)
10244  {
10245  m_EnableAntennaAttemptNotification = value;
10246  }
10247 
10248 
10249 
10250  protected:
10251  std::list<CParameter *> m_listCustom;
10252 
10253  public:
10255  inline std::list<CParameter *>::iterator
10257  {
10258  return m_listCustom.begin();
10259  }
10260 
10262  inline std::list<CParameter *>::iterator
10263  endCustom (void)
10264  {
10265  return m_listCustom.end();
10266  }
10267 
10269  inline void
10271  {
10272  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10273  }
10274 
10276  inline int
10278  {
10279  return (int) (m_listCustom.size());
10280  }
10281 
10282  EResultCode
10284  addCustom (
10285  CParameter * pValue);
10286 
10287 
10288 };
10289 
10290 
10315 class CImpinjAntennaAttemptEvent : public CParameter
10316 {
10317  public:
10320 
10323 
10324  static const CFieldDescriptor * const
10325  s_apFieldDescriptorTable[];
10326 
10327  static const CTypeDescriptor
10328  s_typeDescriptor;
10329 
10330  void
10331  decodeFields (
10332  CDecoderStream * pDecoderStream);
10333 
10334  void
10335  assimilateSubParameters (
10336  CErrorDetails * pError);
10337 
10338  void
10339  encode (
10340  CEncoderStream * pEncoderStream) const;
10341 
10342 
10343  llrp_bool_t
10344  isAllowedIn (
10345  const CTypeDescriptor * pEnclosingElementType) const;
10346 
10347 
10348  static CElement *
10349  s_construct (void);
10350 
10351  static void
10352  s_decodeFields (
10353  CDecoderStream * pDecoderStream,
10354  CElement * pElement);
10356 
10357 
10358  protected:
10359  llrp_u16_t m_AntennaID;
10360 
10363  public:
10364  static const CFieldDescriptor
10365  s_fdAntennaID;
10367 
10369  inline llrp_u16_t
10371  {
10372  return m_AntennaID;
10373  }
10374 
10376  inline void
10378  llrp_u16_t value)
10379  {
10380  m_AntennaID = value;
10381  }
10382 
10383 
10384 
10385  protected:
10386  std::list<CParameter *> m_listCustom;
10387 
10388  public:
10390  inline std::list<CParameter *>::iterator
10392  {
10393  return m_listCustom.begin();
10394  }
10395 
10397  inline std::list<CParameter *>::iterator
10398  endCustom (void)
10399  {
10400  return m_listCustom.end();
10401  }
10402 
10404  inline void
10406  {
10407  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10408  }
10409 
10411  inline int
10413  {
10414  return (int) (m_listCustom.size());
10415  }
10416 
10417  EResultCode
10419  addCustom (
10420  CParameter * pValue);
10421 
10422 
10423 };
10424 
10425 
10453 class CImpinjHubConfiguration : public CParameter
10454 {
10455  public:
10456  CImpinjHubConfiguration (void);
10457  ~CImpinjHubConfiguration (void);
10458 
10461 
10462  static const CFieldDescriptor * const
10463  s_apFieldDescriptorTable[];
10464 
10465  static const CTypeDescriptor
10466  s_typeDescriptor;
10467 
10468  void
10469  decodeFields (
10470  CDecoderStream * pDecoderStream);
10471 
10472  void
10473  assimilateSubParameters (
10474  CErrorDetails * pError);
10475 
10476  void
10477  encode (
10478  CEncoderStream * pEncoderStream) const;
10479 
10480 
10481  llrp_bool_t
10482  isAllowedIn (
10483  const CTypeDescriptor * pEnclosingElementType) const;
10484 
10485 
10486  static CElement *
10487  s_construct (void);
10488 
10489  static void
10490  s_decodeFields (
10491  CDecoderStream * pDecoderStream,
10492  CElement * pElement);
10494 
10495 
10496  protected:
10497  llrp_u16_t m_HubID;
10498 
10501  public:
10502  static const CFieldDescriptor
10503  s_fdHubID;
10505 
10507  inline llrp_u16_t
10508  getHubID (void)
10509  {
10510  return m_HubID;
10511  }
10512 
10514  inline void
10516  llrp_u16_t value)
10517  {
10518  m_HubID = value;
10519  }
10520 
10521 
10522  protected:
10523  EImpinjHubConnectedType m_eConnected;
10524 
10527  public:
10528  static const CFieldDescriptor
10529  s_fdConnected;
10531 
10533  inline EImpinjHubConnectedType
10535  {
10536  return m_eConnected;
10537  }
10538 
10540  inline void
10542  EImpinjHubConnectedType value)
10543  {
10544  m_eConnected = value;
10545  }
10546 
10547 
10548  protected:
10549  EImpinjHubFaultType m_eFault;
10550 
10553  public:
10554  static const CFieldDescriptor
10555  s_fdFault;
10557 
10559  inline EImpinjHubFaultType
10560  getFault (void)
10561  {
10562  return m_eFault;
10563  }
10564 
10566  inline void
10568  EImpinjHubFaultType value)
10569  {
10570  m_eFault = value;
10571  }
10572 
10573 
10574 
10575  protected:
10576  std::list<CParameter *> m_listCustom;
10577 
10578  public:
10580  inline std::list<CParameter *>::iterator
10582  {
10583  return m_listCustom.begin();
10584  }
10585 
10587  inline std::list<CParameter *>::iterator
10588  endCustom (void)
10589  {
10590  return m_listCustom.end();
10591  }
10592 
10594  inline void
10596  {
10597  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10598  }
10599 
10601  inline int
10603  {
10604  return (int) (m_listCustom.size());
10605  }
10606 
10607  EResultCode
10609  addCustom (
10610  CParameter * pValue);
10611 
10612 
10613 };
10614 
10615 
10639 class CImpinjDiagnosticReport : public CParameter
10640 {
10641  public:
10642  CImpinjDiagnosticReport (void);
10643  ~CImpinjDiagnosticReport (void);
10644 
10647 
10648  static const CFieldDescriptor * const
10649  s_apFieldDescriptorTable[];
10650 
10651  static const CTypeDescriptor
10652  s_typeDescriptor;
10653 
10654  void
10655  decodeFields (
10656  CDecoderStream * pDecoderStream);
10657 
10658  void
10659  assimilateSubParameters (
10660  CErrorDetails * pError);
10661 
10662  void
10663  encode (
10664  CEncoderStream * pEncoderStream) const;
10665 
10666 
10667  llrp_bool_t
10668  isAllowedIn (
10669  const CTypeDescriptor * pEnclosingElementType) const;
10670 
10671 
10672  static CElement *
10673  s_construct (void);
10674 
10675  static void
10676  s_decodeFields (
10677  CDecoderStream * pDecoderStream,
10678  CElement * pElement);
10680 
10681 
10682  protected:
10683  llrp_u32v_t m_Metric;
10684 
10687  public:
10688  static const CFieldDescriptor
10689  s_fdMetric;
10691 
10693  inline llrp_u32v_t
10694  getMetric (void)
10695  {
10696  return m_Metric;
10697  }
10698 
10700  inline void
10702  llrp_u32v_t value)
10703  {
10704  m_Metric = value;
10705  }
10706 
10707 
10708 
10709 };
10710 
10711 
10750 class CImpinjPlacementConfiguration : public CParameter
10751 {
10752  public:
10755 
10758 
10759  static const CFieldDescriptor * const
10760  s_apFieldDescriptorTable[];
10761 
10762  static const CTypeDescriptor
10763  s_typeDescriptor;
10764 
10765  void
10766  decodeFields (
10767  CDecoderStream * pDecoderStream);
10768 
10769  void
10770  assimilateSubParameters (
10771  CErrorDetails * pError);
10772 
10773  void
10774  encode (
10775  CEncoderStream * pEncoderStream) const;
10776 
10777 
10778  llrp_bool_t
10779  isAllowedIn (
10780  const CTypeDescriptor * pEnclosingElementType) const;
10781 
10782 
10783  static CElement *
10784  s_construct (void);
10785 
10786  static void
10787  s_decodeFields (
10788  CDecoderStream * pDecoderStream,
10789  CElement * pElement);
10791 
10792 
10793  protected:
10794  llrp_u16_t m_HeightCm;
10795 
10798  public:
10799  static const CFieldDescriptor
10800  s_fdHeightCm;
10802 
10804  inline llrp_u16_t
10806  {
10807  return m_HeightCm;
10808  }
10809 
10811  inline void
10813  llrp_u16_t value)
10814  {
10815  m_HeightCm = value;
10816  }
10817 
10818 
10819  protected:
10820  llrp_s32_t m_FacilityXLocationCm;
10821 
10824  public:
10825  static const CFieldDescriptor
10826  s_fdFacilityXLocationCm;
10828 
10830  inline llrp_s32_t
10832  {
10833  return m_FacilityXLocationCm;
10834  }
10835 
10837  inline void
10839  llrp_s32_t value)
10840  {
10841  m_FacilityXLocationCm = value;
10842  }
10843 
10844 
10845  protected:
10846  llrp_s32_t m_FacilityYLocationCm;
10847 
10850  public:
10851  static const CFieldDescriptor
10852  s_fdFacilityYLocationCm;
10854 
10856  inline llrp_s32_t
10858  {
10859  return m_FacilityYLocationCm;
10860  }
10861 
10863  inline void
10865  llrp_s32_t value)
10866  {
10867  m_FacilityYLocationCm = value;
10868  }
10869 
10870 
10871  protected:
10872  llrp_s16_t m_OrientationDegrees;
10873 
10876  public:
10877  static const CFieldDescriptor
10878  s_fdOrientationDegrees;
10880 
10882  inline llrp_s16_t
10884  {
10885  return m_OrientationDegrees;
10886  }
10887 
10889  inline void
10891  llrp_s16_t value)
10892  {
10893  m_OrientationDegrees = value;
10894  }
10895 
10896 
10897 
10898  protected:
10899  std::list<CParameter *> m_listCustom;
10900 
10901  public:
10903  inline std::list<CParameter *>::iterator
10905  {
10906  return m_listCustom.begin();
10907  }
10908 
10910  inline std::list<CParameter *>::iterator
10911  endCustom (void)
10912  {
10913  return m_listCustom.end();
10914  }
10915 
10917  inline void
10919  {
10920  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10921  }
10922 
10924  inline int
10926  {
10927  return (int) (m_listCustom.size());
10928  }
10929 
10930  EResultCode
10932  addCustom (
10933  CParameter * pValue);
10934 
10935 
10936 };
10937 
10938 
10969 class CImpinjLISpec : public CParameter
10970 {
10971  public:
10972  CImpinjLISpec (void);
10973  ~CImpinjLISpec (void);
10974 
10977 
10978  static const CFieldDescriptor * const
10979  s_apFieldDescriptorTable[];
10980 
10981  static const CTypeDescriptor
10982  s_typeDescriptor;
10983 
10984  void
10985  decodeFields (
10986  CDecoderStream * pDecoderStream);
10987 
10988  void
10989  assimilateSubParameters (
10990  CErrorDetails * pError);
10991 
10992  void
10993  encode (
10994  CEncoderStream * pEncoderStream) const;
10995 
10996 
10997  llrp_bool_t
10998  isAllowedIn (
10999  const CTypeDescriptor * pEnclosingElementType) const;
11000 
11001 
11002  static CElement *
11003  s_construct (void);
11004 
11005  static void
11006  s_decodeFields (
11007  CDecoderStream * pDecoderStream,
11008  CElement * pElement);
11010 
11011 
11012 
11013  protected:
11014  CImpinjLocationConfig * m_pImpinjLocationConfig;
11015 
11016  public:
11018  inline CImpinjLocationConfig *
11020  {
11021  return m_pImpinjLocationConfig;
11022  }
11023 
11025  EResultCode
11026  setImpinjLocationConfig (
11027  CImpinjLocationConfig * pValue);
11028 
11029 
11030  protected:
11031  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
11032 
11033  public:
11035  inline CImpinjC1G2LocationConfig *
11037  {
11038  return m_pImpinjC1G2LocationConfig;
11039  }
11040 
11042  EResultCode
11043  setImpinjC1G2LocationConfig (
11044  CImpinjC1G2LocationConfig * pValue);
11045 
11046 
11047  protected:
11048  CImpinjLocationReporting * m_pImpinjLocationReporting;
11049 
11050  public:
11052  inline CImpinjLocationReporting *
11054  {
11055  return m_pImpinjLocationReporting;
11056  }
11057 
11059  EResultCode
11060  setImpinjLocationReporting (
11061  CImpinjLocationReporting * pValue);
11062 
11063 
11064  protected:
11065  std::list<CParameter *> m_listCustom;
11066 
11067  public:
11069  inline std::list<CParameter *>::iterator
11071  {
11072  return m_listCustom.begin();
11073  }
11074 
11076  inline std::list<CParameter *>::iterator
11077  endCustom (void)
11078  {
11079  return m_listCustom.end();
11080  }
11081 
11083  inline void
11085  {
11086  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11087  }
11088 
11090  inline int
11092  {
11093  return (int) (m_listCustom.size());
11094  }
11095 
11096  EResultCode
11098  addCustom (
11099  CParameter * pValue);
11100 
11101 
11102 };
11103 
11104 
11150 class CImpinjLocationConfig : public CParameter
11151 {
11152  public:
11153  CImpinjLocationConfig (void);
11154  ~CImpinjLocationConfig (void);
11155 
11158 
11159  static const CFieldDescriptor * const
11160  s_apFieldDescriptorTable[];
11161 
11162  static const CTypeDescriptor
11163  s_typeDescriptor;
11164 
11165  void
11166  decodeFields (
11167  CDecoderStream * pDecoderStream);
11168 
11169  void
11170  assimilateSubParameters (
11171  CErrorDetails * pError);
11172 
11173  void
11174  encode (
11175  CEncoderStream * pEncoderStream) const;
11176 
11177 
11178  llrp_bool_t
11179  isAllowedIn (
11180  const CTypeDescriptor * pEnclosingElementType) const;
11181 
11182 
11183  static CElement *
11184  s_construct (void);
11185 
11186  static void
11187  s_decodeFields (
11188  CDecoderStream * pDecoderStream,
11189  CElement * pElement);
11191 
11192 
11193  protected:
11194  llrp_u16_t m_ComputeWindowSeconds;
11195 
11198  public:
11199  static const CFieldDescriptor
11200  s_fdComputeWindowSeconds;
11202 
11204  inline llrp_u16_t
11206  {
11207  return m_ComputeWindowSeconds;
11208  }
11209 
11211  inline void
11213  llrp_u16_t value)
11214  {
11215  m_ComputeWindowSeconds = value;
11216  }
11217 
11218 
11219  protected:
11220  llrp_u16_t m_TagAgeIntervalSeconds;
11221 
11224  public:
11225  static const CFieldDescriptor
11226  s_fdTagAgeIntervalSeconds;
11228 
11230  inline llrp_u16_t
11232  {
11233  return m_TagAgeIntervalSeconds;
11234  }
11235 
11237  inline void
11239  llrp_u16_t value)
11240  {
11241  m_TagAgeIntervalSeconds = value;
11242  }
11243 
11244 
11245  protected:
11246  llrp_u16_t m_UpdateIntervalSeconds;
11247 
11250  public:
11251  static const CFieldDescriptor
11252  s_fdUpdateIntervalSeconds;
11254 
11256  inline llrp_u16_t
11258  {
11259  return m_UpdateIntervalSeconds;
11260  }
11261 
11263  inline void
11265  llrp_u16_t value)
11266  {
11267  m_UpdateIntervalSeconds = value;
11268  }
11269 
11270 
11271 
11272  protected:
11273  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
11274 
11275  public:
11277  inline CImpinjDisabledAntennas *
11279  {
11280  return m_pImpinjDisabledAntennas;
11281  }
11282 
11284  EResultCode
11285  setImpinjDisabledAntennas (
11286  CImpinjDisabledAntennas * pValue);
11287 
11288 
11289  protected:
11290  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
11291 
11292  public:
11296  {
11297  return m_pImpinjLocationAlgorithmControl;
11298  }
11299 
11301  EResultCode
11302  setImpinjLocationAlgorithmControl (
11304 
11305 
11306  protected:
11307  std::list<CParameter *> m_listCustom;
11308 
11309  public:
11311  inline std::list<CParameter *>::iterator
11313  {
11314  return m_listCustom.begin();
11315  }
11316 
11318  inline std::list<CParameter *>::iterator
11319  endCustom (void)
11320  {
11321  return m_listCustom.end();
11322  }
11323 
11325  inline void
11327  {
11328  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11329  }
11330 
11332  inline int
11334  {
11335  return (int) (m_listCustom.size());
11336  }
11337 
11338  EResultCode
11340  addCustom (
11341  CParameter * pValue);
11342 
11343 
11344 };
11345 
11346 
11389 class CImpinjC1G2LocationConfig : public CParameter
11390 {
11391  public:
11393  ~CImpinjC1G2LocationConfig (void);
11394 
11397 
11398  static const CFieldDescriptor * const
11399  s_apFieldDescriptorTable[];
11400 
11401  static const CTypeDescriptor
11402  s_typeDescriptor;
11403 
11404  void
11405  decodeFields (
11406  CDecoderStream * pDecoderStream);
11407 
11408  void
11409  assimilateSubParameters (
11410  CErrorDetails * pError);
11411 
11412  void
11413  encode (
11414  CEncoderStream * pEncoderStream) const;
11415 
11416 
11417  llrp_bool_t
11418  isAllowedIn (
11419  const CTypeDescriptor * pEnclosingElementType) const;
11420 
11421 
11422  static CElement *
11423  s_construct (void);
11424 
11425  static void
11426  s_decodeFields (
11427  CDecoderStream * pDecoderStream,
11428  CElement * pElement);
11430 
11431 
11432  protected:
11433  llrp_u16_t m_ModeIndex;
11434 
11437  public:
11438  static const CFieldDescriptor
11439  s_fdModeIndex;
11441 
11443  inline llrp_u16_t
11445  {
11446  return m_ModeIndex;
11447  }
11448 
11450  inline void
11452  llrp_u16_t value)
11453  {
11454  m_ModeIndex = value;
11455  }
11456 
11457 
11458  protected:
11459  llrp_u2_t m_Session;
11460 
11463  public:
11464  static const CFieldDescriptor
11465  s_fdSession;
11467 
11469  inline llrp_u2_t
11470  getSession (void)
11471  {
11472  return m_Session;
11473  }
11474 
11476  inline void
11478  llrp_u2_t value)
11479  {
11480  m_Session = value;
11481  }
11482 
11483 
11484 
11485  protected:
11486  std::list<CC1G2Filter *> m_listC1G2Filter;
11487 
11488  public:
11490  inline std::list<CC1G2Filter *>::iterator
11492  {
11493  return m_listC1G2Filter.begin();
11494  }
11495 
11497  inline std::list<CC1G2Filter *>::iterator
11499  {
11500  return m_listC1G2Filter.end();
11501  }
11502 
11504  inline void
11506  {
11507  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
11508  }
11509 
11511  inline int
11513  {
11514  return (int) (m_listC1G2Filter.size());
11515  }
11516 
11517  EResultCode
11519  addC1G2Filter (
11520  CC1G2Filter * pValue);
11521 
11522 
11523  protected:
11524  CImpinjTransmitPower * m_pImpinjTransmitPower;
11525 
11526  public:
11528  inline CImpinjTransmitPower *
11530  {
11531  return m_pImpinjTransmitPower;
11532  }
11533 
11535  EResultCode
11536  setImpinjTransmitPower (
11537  CImpinjTransmitPower * pValue);
11538 
11539 
11540  protected:
11541  std::list<CParameter *> m_listCustom;
11542 
11543  public:
11545  inline std::list<CParameter *>::iterator
11547  {
11548  return m_listCustom.begin();
11549  }
11550 
11552  inline std::list<CParameter *>::iterator
11553  endCustom (void)
11554  {
11555  return m_listCustom.end();
11556  }
11557 
11559  inline void
11561  {
11562  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11563  }
11564 
11566  inline int
11568  {
11569  return (int) (m_listCustom.size());
11570  }
11571 
11572  EResultCode
11574  addCustom (
11575  CParameter * pValue);
11576 
11577 
11578 };
11579 
11580 
11622 class CImpinjLocationReporting : public CParameter
11623 {
11624  public:
11625  CImpinjLocationReporting (void);
11626  ~CImpinjLocationReporting (void);
11627 
11630 
11631  static const CFieldDescriptor * const
11632  s_apFieldDescriptorTable[];
11633 
11634  static const CTypeDescriptor
11635  s_typeDescriptor;
11636 
11637  void
11638  decodeFields (
11639  CDecoderStream * pDecoderStream);
11640 
11641  void
11642  assimilateSubParameters (
11643  CErrorDetails * pError);
11644 
11645  void
11646  encode (
11647  CEncoderStream * pEncoderStream) const;
11648 
11649 
11650  llrp_bool_t
11651  isAllowedIn (
11652  const CTypeDescriptor * pEnclosingElementType) const;
11653 
11654 
11655  static CElement *
11656  s_construct (void);
11657 
11658  static void
11659  s_decodeFields (
11660  CDecoderStream * pDecoderStream,
11661  CElement * pElement);
11663 
11664 
11665  protected:
11666  llrp_u1_t m_EnableUpdateReport;
11667 
11670  public:
11671  static const CFieldDescriptor
11672  s_fdEnableUpdateReport;
11674 
11676  inline llrp_u1_t
11678  {
11679  return m_EnableUpdateReport;
11680  }
11681 
11683  inline void
11685  llrp_u1_t value)
11686  {
11687  m_EnableUpdateReport = value;
11688  }
11689 
11690 
11691  protected:
11692  llrp_u1_t m_EnableEntryReport;
11693 
11696  public:
11697  static const CFieldDescriptor
11698  s_fdEnableEntryReport;
11700 
11702  inline llrp_u1_t
11704  {
11705  return m_EnableEntryReport;
11706  }
11707 
11709  inline void
11711  llrp_u1_t value)
11712  {
11713  m_EnableEntryReport = value;
11714  }
11715 
11716 
11717  protected:
11718  llrp_u1_t m_EnableExitReport;
11719 
11722  public:
11723  static const CFieldDescriptor
11724  s_fdEnableExitReport;
11726 
11728  inline llrp_u1_t
11730  {
11731  return m_EnableExitReport;
11732  }
11733 
11735  inline void
11737  llrp_u1_t value)
11738  {
11739  m_EnableExitReport = value;
11740  }
11741 
11742 
11743  protected:
11744  llrp_u1_t m_EnableDiagnosticReport;
11745 
11748  public:
11749  static const CFieldDescriptor
11750  s_fdEnableDiagnosticReport;
11752 
11754  inline llrp_u1_t
11756  {
11757  return m_EnableDiagnosticReport;
11758  }
11759 
11761  inline void
11763  llrp_u1_t value)
11764  {
11765  m_EnableDiagnosticReport = value;
11766  }
11767 
11768 
11769 
11770  protected:
11771  std::list<CParameter *> m_listCustom;
11772 
11773  public:
11775  inline std::list<CParameter *>::iterator
11777  {
11778  return m_listCustom.begin();
11779  }
11780 
11782  inline std::list<CParameter *>::iterator
11783  endCustom (void)
11784  {
11785  return m_listCustom.end();
11786  }
11787 
11789  inline void
11791  {
11792  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11793  }
11794 
11796  inline int
11798  {
11799  return (int) (m_listCustom.size());
11800  }
11801 
11802  EResultCode
11804  addCustom (
11805  CParameter * pValue);
11806 
11807 
11808 };
11809 
11810 
11841 class CImpinjLocationConfidence : public CParameter
11842 {
11843  public:
11845  ~CImpinjLocationConfidence (void);
11846 
11849 
11850  static const CFieldDescriptor * const
11851  s_apFieldDescriptorTable[];
11852 
11853  static const CTypeDescriptor
11854  s_typeDescriptor;
11855 
11856  void
11857  decodeFields (
11858  CDecoderStream * pDecoderStream);
11859 
11860  void
11861  assimilateSubParameters (
11862  CErrorDetails * pError);
11863 
11864  void
11865  encode (
11866  CEncoderStream * pEncoderStream) const;
11867 
11868 
11869  llrp_bool_t
11870  isAllowedIn (
11871  const CTypeDescriptor * pEnclosingElementType) const;
11872 
11873 
11874  static CElement *
11875  s_construct (void);
11876 
11877  static void
11878  s_decodeFields (
11879  CDecoderStream * pDecoderStream,
11880  CElement * pElement);
11882 
11883 
11884  protected:
11885  llrp_u16_t m_ReadCount;
11886 
11889  public:
11890  static const CFieldDescriptor
11891  s_fdReadCount;
11893 
11895  inline llrp_u16_t
11897  {
11898  return m_ReadCount;
11899  }
11900 
11902  inline void
11904  llrp_u16_t value)
11905  {
11906  m_ReadCount = value;
11907  }
11908 
11909 
11910  protected:
11911  llrp_u32v_t m_ConfidenceData;
11912 
11915  public:
11916  static const CFieldDescriptor
11917  s_fdConfidenceData;
11919 
11921  inline llrp_u32v_t
11923  {
11924  return m_ConfidenceData;
11925  }
11926 
11928  inline void
11930  llrp_u32v_t value)
11931  {
11932  m_ConfidenceData = value;
11933  }
11934 
11935 
11936 
11937  protected:
11938  std::list<CParameter *> m_listCustom;
11939 
11940  public:
11942  inline std::list<CParameter *>::iterator
11944  {
11945  return m_listCustom.begin();
11946  }
11947 
11949  inline std::list<CParameter *>::iterator
11950  endCustom (void)
11951  {
11952  return m_listCustom.end();
11953  }
11954 
11956  inline void
11958  {
11959  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11960  }
11961 
11963  inline int
11965  {
11966  return (int) (m_listCustom.size());
11967  }
11968 
11969  EResultCode
11971  addCustom (
11972  CParameter * pValue);
11973 
11974 
11975 };
11976 
11977 
12015 class CImpinjLocationReportData : public CParameter
12016 {
12017  public:
12019  ~CImpinjLocationReportData (void);
12020 
12023 
12024  static const CFieldDescriptor * const
12025  s_apFieldDescriptorTable[];
12026 
12027  static const CTypeDescriptor
12028  s_typeDescriptor;
12029 
12030  void
12031  decodeFields (
12032  CDecoderStream * pDecoderStream);
12033 
12034  void
12035  assimilateSubParameters (
12036  CErrorDetails * pError);
12037 
12038  void
12039  encode (
12040  CEncoderStream * pEncoderStream) const;
12041 
12042 
12043  llrp_bool_t
12044  isAllowedIn (
12045  const CTypeDescriptor * pEnclosingElementType) const;
12046 
12047 
12048  static CElement *
12049  s_construct (void);
12050 
12051  static void
12052  s_decodeFields (
12053  CDecoderStream * pDecoderStream,
12054  CElement * pElement);
12056 
12057 
12058  protected:
12059  llrp_u64_t m_LastSeenTimestampUTC;
12060 
12063  public:
12064  static const CFieldDescriptor
12065  s_fdLastSeenTimestampUTC;
12067 
12069  inline llrp_u64_t
12071  {
12072  return m_LastSeenTimestampUTC;
12073  }
12074 
12076  inline void
12078  llrp_u64_t value)
12079  {
12080  m_LastSeenTimestampUTC = value;
12081  }
12082 
12083 
12084  protected:
12085  llrp_s32_t m_LocXCentimeters;
12086 
12089  public:
12090  static const CFieldDescriptor
12091  s_fdLocXCentimeters;
12093 
12095  inline llrp_s32_t
12097  {
12098  return m_LocXCentimeters;
12099  }
12100 
12102  inline void
12104  llrp_s32_t value)
12105  {
12106  m_LocXCentimeters = value;
12107  }
12108 
12109 
12110  protected:
12111  llrp_s32_t m_LocYCentimeters;
12112 
12115  public:
12116  static const CFieldDescriptor
12117  s_fdLocYCentimeters;
12119 
12121  inline llrp_s32_t
12123  {
12124  return m_LocYCentimeters;
12125  }
12126 
12128  inline void
12130  llrp_s32_t value)
12131  {
12132  m_LocYCentimeters = value;
12133  }
12134 
12135 
12136  protected:
12137  EImpinjLocationReportType m_eType;
12138 
12141  public:
12142  static const CFieldDescriptor
12143  s_fdType;
12145 
12147  inline EImpinjLocationReportType
12148  getType (void)
12149  {
12150  return m_eType;
12151  }
12152 
12154  inline void
12156  EImpinjLocationReportType value)
12157  {
12158  m_eType = value;
12159  }
12160 
12161 
12162 
12163  protected:
12164  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
12165 
12166  public:
12168  inline CImpinjLocationConfidence *
12170  {
12171  return m_pImpinjLocationConfidence;
12172  }
12173 
12175  EResultCode
12176  setImpinjLocationConfidence (
12177  CImpinjLocationConfidence * pValue);
12178 
12179 
12180  protected:
12181  std::list<CParameter *> m_listCustom;
12182 
12183  public:
12185  inline std::list<CParameter *>::iterator
12187  {
12188  return m_listCustom.begin();
12189  }
12190 
12192  inline std::list<CParameter *>::iterator
12193  endCustom (void)
12194  {
12195  return m_listCustom.end();
12196  }
12197 
12199  inline void
12201  {
12202  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12203  }
12204 
12206  inline int
12208  {
12209  return (int) (m_listCustom.size());
12210  }
12211 
12212  EResultCode
12214  addCustom (
12215  CParameter * pValue);
12216 
12217 
12218 };
12219 
12220 
12253 class CImpinjDISpec : public CParameter
12254 {
12255  public:
12256  CImpinjDISpec (void);
12257  ~CImpinjDISpec (void);
12258 
12261 
12262  static const CFieldDescriptor * const
12263  s_apFieldDescriptorTable[];
12264 
12265  static const CTypeDescriptor
12266  s_typeDescriptor;
12267 
12268  void
12269  decodeFields (
12270  CDecoderStream * pDecoderStream);
12271 
12272  void
12273  assimilateSubParameters (
12274  CErrorDetails * pError);
12275 
12276  void
12277  encode (
12278  CEncoderStream * pEncoderStream) const;
12279 
12280 
12281  llrp_bool_t
12282  isAllowedIn (
12283  const CTypeDescriptor * pEnclosingElementType) const;
12284 
12285 
12286  static CElement *
12287  s_construct (void);
12288 
12289  static void
12290  s_decodeFields (
12291  CDecoderStream * pDecoderStream,
12292  CElement * pElement);
12294 
12295 
12296 
12297  protected:
12298  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
12299 
12300  public:
12302  inline CImpinjDirectionSectors *
12304  {
12305  return m_pImpinjDirectionSectors;
12306  }
12307 
12309  EResultCode
12310  setImpinjDirectionSectors (
12311  CImpinjDirectionSectors * pValue);
12312 
12313 
12314  protected:
12315  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
12316 
12317  public:
12319  inline CImpinjDirectionConfig *
12321  {
12322  return m_pImpinjDirectionConfig;
12323  }
12324 
12326  EResultCode
12327  setImpinjDirectionConfig (
12328  CImpinjDirectionConfig * pValue);
12329 
12330 
12331  protected:
12332  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
12333 
12334  public:
12338  {
12339  return m_pImpinjC1G2DirectionConfig;
12340  }
12341 
12343  EResultCode
12344  setImpinjC1G2DirectionConfig (
12345  CImpinjC1G2DirectionConfig * pValue);
12346 
12347 
12348  protected:
12349  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
12350 
12351  public:
12353  inline CImpinjDirectionReporting *
12355  {
12356  return m_pImpinjDirectionReporting;
12357  }
12358 
12360  EResultCode
12361  setImpinjDirectionReporting (
12362  CImpinjDirectionReporting * pValue);
12363 
12364 
12365  protected:
12366  std::list<CParameter *> m_listCustom;
12367 
12368  public:
12370  inline std::list<CParameter *>::iterator
12372  {
12373  return m_listCustom.begin();
12374  }
12375 
12377  inline std::list<CParameter *>::iterator
12378  endCustom (void)
12379  {
12380  return m_listCustom.end();
12381  }
12382 
12384  inline void
12386  {
12387  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12388  }
12389 
12391  inline int
12393  {
12394  return (int) (m_listCustom.size());
12395  }
12396 
12397  EResultCode
12399  addCustom (
12400  CParameter * pValue);
12401 
12402 
12403 };
12404 
12405 
12433 class CImpinjDirectionSectors : public CParameter
12434 {
12435  public:
12436  CImpinjDirectionSectors (void);
12437  ~CImpinjDirectionSectors (void);
12438 
12441 
12442  static const CFieldDescriptor * const
12443  s_apFieldDescriptorTable[];
12444 
12445  static const CTypeDescriptor
12446  s_typeDescriptor;
12447 
12448  void
12449  decodeFields (
12450  CDecoderStream * pDecoderStream);
12451 
12452  void
12453  assimilateSubParameters (
12454  CErrorDetails * pError);
12455 
12456  void
12457  encode (
12458  CEncoderStream * pEncoderStream) const;
12459 
12460 
12461  llrp_bool_t
12462  isAllowedIn (
12463  const CTypeDescriptor * pEnclosingElementType) const;
12464 
12465 
12466  static CElement *
12467  s_construct (void);
12468 
12469  static void
12470  s_decodeFields (
12471  CDecoderStream * pDecoderStream,
12472  CElement * pElement);
12474 
12475 
12476  protected:
12477  llrp_u16v_t m_EnabledSectorIDs;
12478 
12481  public:
12482  static const CFieldDescriptor
12483  s_fdEnabledSectorIDs;
12485 
12487  inline llrp_u16v_t
12489  {
12490  return m_EnabledSectorIDs;
12491  }
12492 
12494  inline void
12496  llrp_u16v_t value)
12497  {
12498  m_EnabledSectorIDs = value;
12499  }
12500 
12501 
12502 
12503  protected:
12504  std::list<CParameter *> m_listCustom;
12505 
12506  public:
12508  inline std::list<CParameter *>::iterator
12510  {
12511  return m_listCustom.begin();
12512  }
12513 
12515  inline std::list<CParameter *>::iterator
12516  endCustom (void)
12517  {
12518  return m_listCustom.end();
12519  }
12520 
12522  inline void
12524  {
12525  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12526  }
12527 
12529  inline int
12531  {
12532  return (int) (m_listCustom.size());
12533  }
12534 
12535  EResultCode
12537  addCustom (
12538  CParameter * pValue);
12539 
12540 
12541 };
12542 
12543 
12582 class CImpinjDirectionConfig : public CParameter
12583 {
12584  public:
12585  CImpinjDirectionConfig (void);
12586  ~CImpinjDirectionConfig (void);
12587 
12590 
12591  static const CFieldDescriptor * const
12592  s_apFieldDescriptorTable[];
12593 
12594  static const CTypeDescriptor
12595  s_typeDescriptor;
12596 
12597  void
12598  decodeFields (
12599  CDecoderStream * pDecoderStream);
12600 
12601  void
12602  assimilateSubParameters (
12603  CErrorDetails * pError);
12604 
12605  void
12606  encode (
12607  CEncoderStream * pEncoderStream) const;
12608 
12609 
12610  llrp_bool_t
12611  isAllowedIn (
12612  const CTypeDescriptor * pEnclosingElementType) const;
12613 
12614 
12615  static CElement *
12616  s_construct (void);
12617 
12618  static void
12619  s_decodeFields (
12620  CDecoderStream * pDecoderStream,
12621  CElement * pElement);
12623 
12624 
12625  protected:
12626  llrp_u16_t m_TagAgeIntervalSeconds;
12627 
12630  public:
12631  static const CFieldDescriptor
12632  s_fdTagAgeIntervalSeconds;
12634 
12636  inline llrp_u16_t
12638  {
12639  return m_TagAgeIntervalSeconds;
12640  }
12641 
12643  inline void
12645  llrp_u16_t value)
12646  {
12647  m_TagAgeIntervalSeconds = value;
12648  }
12649 
12650 
12651  protected:
12652  llrp_u16_t m_UpdateIntervalSeconds;
12653 
12656  public:
12657  static const CFieldDescriptor
12658  s_fdUpdateIntervalSeconds;
12660 
12662  inline llrp_u16_t
12664  {
12665  return m_UpdateIntervalSeconds;
12666  }
12667 
12669  inline void
12671  llrp_u16_t value)
12672  {
12673  m_UpdateIntervalSeconds = value;
12674  }
12675 
12676 
12677  protected:
12678  EImpinjDirectionFieldOfView m_eFieldOfView;
12679 
12682  public:
12683  static const CFieldDescriptor
12684  s_fdFieldOfView;
12686 
12688  inline EImpinjDirectionFieldOfView
12690  {
12691  return m_eFieldOfView;
12692  }
12693 
12695  inline void
12697  EImpinjDirectionFieldOfView value)
12698  {
12699  m_eFieldOfView = value;
12700  }
12701 
12702 
12703 
12704  protected:
12705  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12706 
12707  public:
12711  {
12712  return m_pImpinjDirectionUserTagPopulationLimit;
12713  }
12714 
12716  EResultCode
12717  setImpinjDirectionUserTagPopulationLimit (
12719 
12720 
12721  protected:
12722  std::list<CParameter *> m_listCustom;
12723 
12724  public:
12726  inline std::list<CParameter *>::iterator
12728  {
12729  return m_listCustom.begin();
12730  }
12731 
12733  inline std::list<CParameter *>::iterator
12734  endCustom (void)
12735  {
12736  return m_listCustom.end();
12737  }
12738 
12740  inline void
12742  {
12743  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12744  }
12745 
12747  inline int
12749  {
12750  return (int) (m_listCustom.size());
12751  }
12752 
12753  EResultCode
12755  addCustom (
12756  CParameter * pValue);
12757 
12758 
12759 };
12760 
12761 
12785 {
12786  public:
12789 
12792 
12793  static const CFieldDescriptor * const
12794  s_apFieldDescriptorTable[];
12795 
12796  static const CTypeDescriptor
12797  s_typeDescriptor;
12798 
12799  void
12800  decodeFields (
12801  CDecoderStream * pDecoderStream);
12802 
12803  void
12804  assimilateSubParameters (
12805  CErrorDetails * pError);
12806 
12807  void
12808  encode (
12809  CEncoderStream * pEncoderStream) const;
12810 
12811 
12812  llrp_bool_t
12813  isAllowedIn (
12814  const CTypeDescriptor * pEnclosingElementType) const;
12815 
12816 
12817  static CElement *
12818  s_construct (void);
12819 
12820  static void
12821  s_decodeFields (
12822  CDecoderStream * pDecoderStream,
12823  CElement * pElement);
12825 
12826 
12827  protected:
12828  llrp_u16_t m_UserTagPopulationLimit;
12829 
12832  public:
12833  static const CFieldDescriptor
12834  s_fdUserTagPopulationLimit;
12836 
12838  inline llrp_u16_t
12840  {
12841  return m_UserTagPopulationLimit;
12842  }
12843 
12845  inline void
12847  llrp_u16_t value)
12848  {
12849  m_UserTagPopulationLimit = value;
12850  }
12851 
12852 
12853 
12854 };
12855 
12856 
12894 class CImpinjC1G2DirectionConfig : public CParameter
12895 {
12896  public:
12899 
12902 
12903  static const CFieldDescriptor * const
12904  s_apFieldDescriptorTable[];
12905 
12906  static const CTypeDescriptor
12907  s_typeDescriptor;
12908 
12909  void
12910  decodeFields (
12911  CDecoderStream * pDecoderStream);
12912 
12913  void
12914  assimilateSubParameters (
12915  CErrorDetails * pError);
12916 
12917  void
12918  encode (
12919  CEncoderStream * pEncoderStream) const;
12920 
12921 
12922  llrp_bool_t
12923  isAllowedIn (
12924  const CTypeDescriptor * pEnclosingElementType) const;
12925 
12926 
12927  static CElement *
12928  s_construct (void);
12929 
12930  static void
12931  s_decodeFields (
12932  CDecoderStream * pDecoderStream,
12933  CElement * pElement);
12935 
12936 
12937  protected:
12938  EImpinjDirectionRFMode m_eRFMode;
12939 
12942  public:
12943  static const CFieldDescriptor
12944  s_fdRFMode;
12946 
12948  inline EImpinjDirectionRFMode
12949  getRFMode (void)
12950  {
12951  return m_eRFMode;
12952  }
12953 
12955  inline void
12957  EImpinjDirectionRFMode value)
12958  {
12959  m_eRFMode = value;
12960  }
12961 
12962 
12963 
12964  protected:
12965  CImpinjTransmitPower * m_pImpinjTransmitPower;
12966 
12967  public:
12969  inline CImpinjTransmitPower *
12971  {
12972  return m_pImpinjTransmitPower;
12973  }
12974 
12976  EResultCode
12977  setImpinjTransmitPower (
12978  CImpinjTransmitPower * pValue);
12979 
12980 
12981  protected:
12982  std::list<CC1G2Filter *> m_listC1G2Filter;
12983 
12984  public:
12986  inline std::list<CC1G2Filter *>::iterator
12988  {
12989  return m_listC1G2Filter.begin();
12990  }
12991 
12993  inline std::list<CC1G2Filter *>::iterator
12995  {
12996  return m_listC1G2Filter.end();
12997  }
12998 
13000  inline void
13002  {
13003  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
13004  }
13005 
13007  inline int
13009  {
13010  return (int) (m_listC1G2Filter.size());
13011  }
13012 
13013  EResultCode
13015  addC1G2Filter (
13016  CC1G2Filter * pValue);
13017 
13018 
13019  protected:
13020  std::list<CParameter *> m_listCustom;
13021 
13022  public:
13024  inline std::list<CParameter *>::iterator
13026  {
13027  return m_listCustom.begin();
13028  }
13029 
13031  inline std::list<CParameter *>::iterator
13032  endCustom (void)
13033  {
13034  return m_listCustom.end();
13035  }
13036 
13038  inline void
13040  {
13041  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13042  }
13043 
13045  inline int
13047  {
13048  return (int) (m_listCustom.size());
13049  }
13050 
13051  EResultCode
13053  addCustom (
13054  CParameter * pValue);
13055 
13056 
13057 };
13058 
13059 
13092 class CImpinjExtendedTagInformation : public CParameter
13093 {
13094  public:
13097 
13100 
13101  static const CFieldDescriptor * const
13102  s_apFieldDescriptorTable[];
13103 
13104  static const CTypeDescriptor
13105  s_typeDescriptor;
13106 
13107  void
13108  decodeFields (
13109  CDecoderStream * pDecoderStream);
13110 
13111  void
13112  assimilateSubParameters (
13113  CErrorDetails * pError);
13114 
13115  void
13116  encode (
13117  CEncoderStream * pEncoderStream) const;
13118 
13119 
13120  llrp_bool_t
13121  isAllowedIn (
13122  const CTypeDescriptor * pEnclosingElementType) const;
13123 
13124 
13125  static CElement *
13126  s_construct (void);
13127 
13128  static void
13129  s_decodeFields (
13130  CDecoderStream * pDecoderStream,
13131  CElement * pElement);
13133 
13134 
13135 
13136  protected:
13137  std::list<CEPCData *> m_listEPCData;
13138 
13139  public:
13141  inline std::list<CEPCData *>::iterator
13143  {
13144  return m_listEPCData.begin();
13145  }
13146 
13148  inline std::list<CEPCData *>::iterator
13149  endEPCData (void)
13150  {
13151  return m_listEPCData.end();
13152  }
13153 
13155  inline void
13157  {
13158  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
13159  }
13160 
13162  inline int
13164  {
13165  return (int) (m_listEPCData.size());
13166  }
13167 
13168  EResultCode
13170  addEPCData (
13171  CEPCData * pValue);
13172 
13173 
13174  protected:
13175  CImpinjLocationReportData * m_pImpinjLocationReportData;
13176 
13177  public:
13179  inline CImpinjLocationReportData *
13181  {
13182  return m_pImpinjLocationReportData;
13183  }
13184 
13186  EResultCode
13187  setImpinjLocationReportData (
13188  CImpinjLocationReportData * pValue);
13189 
13190 
13191  protected:
13192  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
13193 
13194  public:
13198  {
13199  return m_pImpinjDirectionReportData;
13200  }
13201 
13203  EResultCode
13204  setImpinjDirectionReportData (
13205  CImpinjDirectionReportData * pValue);
13206 
13207 
13208  protected:
13209  std::list<CParameter *> m_listCustom;
13210 
13211  public:
13213  inline std::list<CParameter *>::iterator
13215  {
13216  return m_listCustom.begin();
13217  }
13218 
13220  inline std::list<CParameter *>::iterator
13221  endCustom (void)
13222  {
13223  return m_listCustom.end();
13224  }
13225 
13227  inline void
13229  {
13230  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13231  }
13232 
13234  inline int
13236  {
13237  return (int) (m_listCustom.size());
13238  }
13239 
13240  EResultCode
13242  addCustom (
13243  CParameter * pValue);
13244 
13245 
13246 };
13247 
13248 
13295 class CImpinjDirectionReporting : public CParameter
13296 {
13297  public:
13299  ~CImpinjDirectionReporting (void);
13300 
13303 
13304  static const CFieldDescriptor * const
13305  s_apFieldDescriptorTable[];
13306 
13307  static const CTypeDescriptor
13308  s_typeDescriptor;
13309 
13310  void
13311  decodeFields (
13312  CDecoderStream * pDecoderStream);
13313 
13314  void
13315  assimilateSubParameters (
13316  CErrorDetails * pError);
13317 
13318  void
13319  encode (
13320  CEncoderStream * pEncoderStream) const;
13321 
13322 
13323  llrp_bool_t
13324  isAllowedIn (
13325  const CTypeDescriptor * pEnclosingElementType) const;
13326 
13327 
13328  static CElement *
13329  s_construct (void);
13330 
13331  static void
13332  s_decodeFields (
13333  CDecoderStream * pDecoderStream,
13334  CElement * pElement);
13336 
13337 
13338  protected:
13339  llrp_u1_t m_EnableUpdateReport;
13340 
13343  public:
13344  static const CFieldDescriptor
13345  s_fdEnableUpdateReport;
13347 
13349  inline llrp_u1_t
13351  {
13352  return m_EnableUpdateReport;
13353  }
13354 
13356  inline void
13358  llrp_u1_t value)
13359  {
13360  m_EnableUpdateReport = value;
13361  }
13362 
13363 
13364  protected:
13365  llrp_u1_t m_EnableEntryReport;
13366 
13369  public:
13370  static const CFieldDescriptor
13371  s_fdEnableEntryReport;
13373 
13375  inline llrp_u1_t
13377  {
13378  return m_EnableEntryReport;
13379  }
13380 
13382  inline void
13384  llrp_u1_t value)
13385  {
13386  m_EnableEntryReport = value;
13387  }
13388 
13389 
13390  protected:
13391  llrp_u1_t m_EnableExitReport;
13392 
13395  public:
13396  static const CFieldDescriptor
13397  s_fdEnableExitReport;
13399 
13401  inline llrp_u1_t
13403  {
13404  return m_EnableExitReport;
13405  }
13406 
13408  inline void
13410  llrp_u1_t value)
13411  {
13412  m_EnableExitReport = value;
13413  }
13414 
13415 
13416  protected:
13417  llrp_u1_t m_EnableDiagnosticReport;
13418 
13421  public:
13422  static const CFieldDescriptor
13423  s_fdEnableDiagnosticReport;
13425 
13427  inline llrp_u1_t
13429  {
13430  return m_EnableDiagnosticReport;
13431  }
13432 
13434  inline void
13436  llrp_u1_t value)
13437  {
13438  m_EnableDiagnosticReport = value;
13439  }
13440 
13441 
13442  protected:
13443  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
13444 
13447  public:
13448  static const CFieldDescriptor
13449  s_fdDiagnosticReportLevel;
13451 
13453  inline EImpinjDirectionDiagnosticReportLevel
13455  {
13456  return m_eDiagnosticReportLevel;
13457  }
13458 
13460  inline void
13462  EImpinjDirectionDiagnosticReportLevel value)
13463  {
13464  m_eDiagnosticReportLevel = value;
13465  }
13466 
13467 
13468 
13469  protected:
13470  std::list<CParameter *> m_listCustom;
13471 
13472  public:
13474  inline std::list<CParameter *>::iterator
13476  {
13477  return m_listCustom.begin();
13478  }
13479 
13481  inline std::list<CParameter *>::iterator
13482  endCustom (void)
13483  {
13484  return m_listCustom.end();
13485  }
13486 
13488  inline void
13490  {
13491  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13492  }
13493 
13495  inline int
13497  {
13498  return (int) (m_listCustom.size());
13499  }
13500 
13501  EResultCode
13503  addCustom (
13504  CParameter * pValue);
13505 
13506 
13507 };
13508 
13509 
13557 class CImpinjDirectionReportData : public CParameter
13558 {
13559  public:
13562 
13565 
13566  static const CFieldDescriptor * const
13567  s_apFieldDescriptorTable[];
13568 
13569  static const CTypeDescriptor
13570  s_typeDescriptor;
13571 
13572  void
13573  decodeFields (
13574  CDecoderStream * pDecoderStream);
13575 
13576  void
13577  assimilateSubParameters (
13578  CErrorDetails * pError);
13579 
13580  void
13581  encode (
13582  CEncoderStream * pEncoderStream) const;
13583 
13584 
13585  llrp_bool_t
13586  isAllowedIn (
13587  const CTypeDescriptor * pEnclosingElementType) const;
13588 
13589 
13590  static CElement *
13591  s_construct (void);
13592 
13593  static void
13594  s_decodeFields (
13595  CDecoderStream * pDecoderStream,
13596  CElement * pElement);
13598 
13599 
13600  protected:
13601  EImpinjDirectionReportType m_eType;
13602 
13605  public:
13606  static const CFieldDescriptor
13607  s_fdType;
13609 
13611  inline EImpinjDirectionReportType
13612  getType (void)
13613  {
13614  return m_eType;
13615  }
13616 
13618  inline void
13620  EImpinjDirectionReportType value)
13621  {
13622  m_eType = value;
13623  }
13624 
13625 
13626  protected:
13627  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13628 
13631  public:
13632  static const CFieldDescriptor
13633  s_fdTagPopulationStatus;
13635 
13637  inline EImpinjDirectionTagPopulationStatus
13639  {
13640  return m_eTagPopulationStatus;
13641  }
13642 
13644  inline void
13646  EImpinjDirectionTagPopulationStatus value)
13647  {
13648  m_eTagPopulationStatus = value;
13649  }
13650 
13651 
13652  protected:
13653  llrp_u8_t m_FirstSeenSectorID;
13654 
13657  public:
13658  static const CFieldDescriptor
13659  s_fdFirstSeenSectorID;
13661 
13663  inline llrp_u8_t
13665  {
13666  return m_FirstSeenSectorID;
13667  }
13668 
13670  inline void
13672  llrp_u8_t value)
13673  {
13674  m_FirstSeenSectorID = value;
13675  }
13676 
13677 
13678  protected:
13679  llrp_u64_t m_FirstSeenTimestampUTC;
13680 
13683  public:
13684  static const CFieldDescriptor
13685  s_fdFirstSeenTimestampUTC;
13687 
13689  inline llrp_u64_t
13691  {
13692  return m_FirstSeenTimestampUTC;
13693  }
13694 
13696  inline void
13698  llrp_u64_t value)
13699  {
13700  m_FirstSeenTimestampUTC = value;
13701  }
13702 
13703 
13704  protected:
13705  llrp_u8_t m_LastSeenSectorID;
13706 
13709  public:
13710  static const CFieldDescriptor
13711  s_fdLastSeenSectorID;
13713 
13715  inline llrp_u8_t
13717  {
13718  return m_LastSeenSectorID;
13719  }
13720 
13722  inline void
13724  llrp_u8_t value)
13725  {
13726  m_LastSeenSectorID = value;
13727  }
13728 
13729 
13730  protected:
13731  llrp_u64_t m_LastSeenTimestampUTC;
13732 
13735  public:
13736  static const CFieldDescriptor
13737  s_fdLastSeenTimestampUTC;
13739 
13741  inline llrp_u64_t
13743  {
13744  return m_LastSeenTimestampUTC;
13745  }
13746 
13748  inline void
13750  llrp_u64_t value)
13751  {
13752  m_LastSeenTimestampUTC = value;
13753  }
13754 
13755 
13756 
13757  protected:
13758  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13759 
13760  public:
13764  {
13765  return m_pImpinjDirectionDiagnosticData;
13766  }
13767 
13769  EResultCode
13770  setImpinjDirectionDiagnosticData (
13772 
13773 
13774  protected:
13775  std::list<CParameter *> m_listCustom;
13776 
13777  public:
13779  inline std::list<CParameter *>::iterator
13781  {
13782  return m_listCustom.begin();
13783  }
13784 
13786  inline std::list<CParameter *>::iterator
13787  endCustom (void)
13788  {
13789  return m_listCustom.end();
13790  }
13791 
13793  inline void
13795  {
13796  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13797  }
13798 
13800  inline int
13802  {
13803  return (int) (m_listCustom.size());
13804  }
13805 
13806  EResultCode
13808  addCustom (
13809  CParameter * pValue);
13810 
13811 
13812 };
13813 
13814 
13837 class CImpinjDirectionDiagnosticData : public CParameter
13838 {
13839  public:
13842 
13845 
13846  static const CFieldDescriptor * const
13847  s_apFieldDescriptorTable[];
13848 
13849  static const CTypeDescriptor
13850  s_typeDescriptor;
13851 
13852  void
13853  decodeFields (
13854  CDecoderStream * pDecoderStream);
13855 
13856  void
13857  assimilateSubParameters (
13858  CErrorDetails * pError);
13859 
13860  void
13861  encode (
13862  CEncoderStream * pEncoderStream) const;
13863 
13864 
13865  llrp_bool_t
13866  isAllowedIn (
13867  const CTypeDescriptor * pEnclosingElementType) const;
13868 
13869 
13870  static CElement *
13871  s_construct (void);
13872 
13873  static void
13874  s_decodeFields (
13875  CDecoderStream * pDecoderStream,
13876  CElement * pElement);
13878 
13879 
13880  protected:
13881  llrp_u32v_t m_Metric;
13882 
13885  public:
13886  static const CFieldDescriptor
13887  s_fdMetric;
13889 
13891  inline llrp_u32v_t
13892  getMetric (void)
13893  {
13894  return m_Metric;
13895  }
13896 
13898  inline void
13900  llrp_u32v_t value)
13901  {
13902  m_Metric = value;
13903  }
13904 
13905 
13906 
13907 };
13908 
13909 
13934 class CImpinjxArrayDirectionCapabilities : public CParameter
13935 {
13936  public:
13939 
13942 
13943  static const CFieldDescriptor * const
13944  s_apFieldDescriptorTable[];
13945 
13946  static const CTypeDescriptor
13947  s_typeDescriptor;
13948 
13949  void
13950  decodeFields (
13951  CDecoderStream * pDecoderStream);
13952 
13953  void
13954  assimilateSubParameters (
13955  CErrorDetails * pError);
13956 
13957  void
13958  encode (
13959  CEncoderStream * pEncoderStream) const;
13960 
13961 
13962  llrp_bool_t
13963  isAllowedIn (
13964  const CTypeDescriptor * pEnclosingElementType) const;
13965 
13966 
13967  static CElement *
13968  s_construct (void);
13969 
13970  static void
13971  s_decodeFields (
13972  CDecoderStream * pDecoderStream,
13973  CElement * pElement);
13975 
13976 
13977  protected:
13978  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13979 
13982  public:
13983  static const CFieldDescriptor
13984  s_fdSystemTagPopulationLimitHighSensitivity;
13986 
13988  inline llrp_u16_t
13990  {
13991  return m_SystemTagPopulationLimitHighSensitivity;
13992  }
13993 
13995  inline void
13997  llrp_u16_t value)
13998  {
13999  m_SystemTagPopulationLimitHighSensitivity = value;
14000  }
14001 
14002 
14003  protected:
14004  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
14005 
14008  public:
14009  static const CFieldDescriptor
14010  s_fdSystemTagPopulationLimitHighPerformance;
14012 
14014  inline llrp_u16_t
14016  {
14017  return m_SystemTagPopulationLimitHighPerformance;
14018  }
14019 
14021  inline void
14023  llrp_u16_t value)
14024  {
14025  m_SystemTagPopulationLimitHighPerformance = value;
14026  }
14027 
14028 
14029 
14030  protected:
14031  std::list<CParameter *> m_listCustom;
14032 
14033  public:
14035  inline std::list<CParameter *>::iterator
14037  {
14038  return m_listCustom.begin();
14039  }
14040 
14042  inline std::list<CParameter *>::iterator
14043  endCustom (void)
14044  {
14045  return m_listCustom.end();
14046  }
14047 
14049  inline void
14051  {
14052  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14053  }
14054 
14056  inline int
14058  {
14059  return (int) (m_listCustom.size());
14060  }
14061 
14062  EResultCode
14064  addCustom (
14065  CParameter * pValue);
14066 
14067 
14068 };
14069 
14070 
14096 class CImpinjIntelligentAntennaManagement : public CParameter
14097 {
14098  public:
14101 
14104 
14105  static const CFieldDescriptor * const
14106  s_apFieldDescriptorTable[];
14107 
14108  static const CTypeDescriptor
14109  s_typeDescriptor;
14110 
14111  void
14112  decodeFields (
14113  CDecoderStream * pDecoderStream);
14114 
14115  void
14116  assimilateSubParameters (
14117  CErrorDetails * pError);
14118 
14119  void
14120  encode (
14121  CEncoderStream * pEncoderStream) const;
14122 
14123 
14124  llrp_bool_t
14125  isAllowedIn (
14126  const CTypeDescriptor * pEnclosingElementType) const;
14127 
14128 
14129  static CElement *
14130  s_construct (void);
14131 
14132  static void
14133  s_decodeFields (
14134  CDecoderStream * pDecoderStream,
14135  CElement * pElement);
14137 
14138 
14139  protected:
14140  EImpinjIntelligentAntennaMode m_eManagementEnabled;
14141 
14144  public:
14145  static const CFieldDescriptor
14146  s_fdManagementEnabled;
14148 
14150  inline EImpinjIntelligentAntennaMode
14152  {
14153  return m_eManagementEnabled;
14154  }
14155 
14157  inline void
14159  EImpinjIntelligentAntennaMode value)
14160  {
14161  m_eManagementEnabled = value;
14162  }
14163 
14164 
14165 
14166  protected:
14167  std::list<CParameter *> m_listCustom;
14168 
14169  public:
14171  inline std::list<CParameter *>::iterator
14173  {
14174  return m_listCustom.begin();
14175  }
14176 
14178  inline std::list<CParameter *>::iterator
14179  endCustom (void)
14180  {
14181  return m_listCustom.end();
14182  }
14183 
14185  inline void
14187  {
14188  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14189  }
14190 
14192  inline int
14194  {
14195  return (int) (m_listCustom.size());
14196  }
14197 
14198  EResultCode
14200  addCustom (
14201  CParameter * pValue);
14202 
14203 
14204 };
14205 
14206 
14233 class CImpinjTransmitPower : public CParameter
14234 {
14235  public:
14236  CImpinjTransmitPower (void);
14237  ~CImpinjTransmitPower (void);
14238 
14241 
14242  static const CFieldDescriptor * const
14243  s_apFieldDescriptorTable[];
14244 
14245  static const CTypeDescriptor
14246  s_typeDescriptor;
14247 
14248  void
14249  decodeFields (
14250  CDecoderStream * pDecoderStream);
14251 
14252  void
14253  assimilateSubParameters (
14254  CErrorDetails * pError);
14255 
14256  void
14257  encode (
14258  CEncoderStream * pEncoderStream) const;
14259 
14260 
14261  llrp_bool_t
14262  isAllowedIn (
14263  const CTypeDescriptor * pEnclosingElementType) const;
14264 
14265 
14266  static CElement *
14267  s_construct (void);
14268 
14269  static void
14270  s_decodeFields (
14271  CDecoderStream * pDecoderStream,
14272  CElement * pElement);
14274 
14275 
14276  protected:
14277  llrp_u16_t m_TransmitPower;
14278 
14281  public:
14282  static const CFieldDescriptor
14283  s_fdTransmitPower;
14285 
14287  inline llrp_u16_t
14289  {
14290  return m_TransmitPower;
14291  }
14292 
14294  inline void
14296  llrp_u16_t value)
14297  {
14298  m_TransmitPower = value;
14299  }
14300 
14301 
14302 
14303  protected:
14304  std::list<CParameter *> m_listCustom;
14305 
14306  public:
14308  inline std::list<CParameter *>::iterator
14310  {
14311  return m_listCustom.begin();
14312  }
14313 
14315  inline std::list<CParameter *>::iterator
14316  endCustom (void)
14317  {
14318  return m_listCustom.end();
14319  }
14320 
14322  inline void
14324  {
14325  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14326  }
14327 
14329  inline int
14331  {
14332  return (int) (m_listCustom.size());
14333  }
14334 
14335  EResultCode
14337  addCustom (
14338  CParameter * pValue);
14339 
14340 
14341 };
14342 
14343 
14370 class CImpinjPolarizationControl : public CParameter
14371 {
14372  public:
14375 
14378 
14379  static const CFieldDescriptor * const
14380  s_apFieldDescriptorTable[];
14381 
14382  static const CTypeDescriptor
14383  s_typeDescriptor;
14384 
14385  void
14386  decodeFields (
14387  CDecoderStream * pDecoderStream);
14388 
14389  void
14390  assimilateSubParameters (
14391  CErrorDetails * pError);
14392 
14393  void
14394  encode (
14395  CEncoderStream * pEncoderStream) const;
14396 
14397 
14398  llrp_bool_t
14399  isAllowedIn (
14400  const CTypeDescriptor * pEnclosingElementType) const;
14401 
14402 
14403  static CElement *
14404  s_construct (void);
14405 
14406  static void
14407  s_decodeFields (
14408  CDecoderStream * pDecoderStream,
14409  CElement * pElement);
14411 
14412 
14413  protected:
14414  llrp_u1_t m_PolarizationControlEnabled;
14415 
14418  public:
14419  static const CFieldDescriptor
14420  s_fdPolarizationControlEnabled;
14422 
14424  inline llrp_u1_t
14426  {
14427  return m_PolarizationControlEnabled;
14428  }
14429 
14431  inline void
14433  llrp_u1_t value)
14434  {
14435  m_PolarizationControlEnabled = value;
14436  }
14437 
14438 
14439 
14440  protected:
14441  std::list<CParameter *> m_listCustom;
14442 
14443  public:
14445  inline std::list<CParameter *>::iterator
14447  {
14448  return m_listCustom.begin();
14449  }
14450 
14452  inline std::list<CParameter *>::iterator
14453  endCustom (void)
14454  {
14455  return m_listCustom.end();
14456  }
14457 
14459  inline void
14461  {
14462  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14463  }
14464 
14466  inline int
14468  {
14469  return (int) (m_listCustom.size());
14470  }
14471 
14472  EResultCode
14474  addCustom (
14475  CParameter * pValue);
14476 
14477 
14478 };
14479 
14480 
14505 class CImpinjAntennaCapabilities : public CParameter
14506 {
14507  public:
14510 
14513 
14514  static const CFieldDescriptor * const
14515  s_apFieldDescriptorTable[];
14516 
14517  static const CTypeDescriptor
14518  s_typeDescriptor;
14519 
14520  void
14521  decodeFields (
14522  CDecoderStream * pDecoderStream);
14523 
14524  void
14525  assimilateSubParameters (
14526  CErrorDetails * pError);
14527 
14528  void
14529  encode (
14530  CEncoderStream * pEncoderStream) const;
14531 
14532 
14533  llrp_bool_t
14534  isAllowedIn (
14535  const CTypeDescriptor * pEnclosingElementType) const;
14536 
14537 
14538  static CElement *
14539  s_construct (void);
14540 
14541  static void
14542  s_decodeFields (
14543  CDecoderStream * pDecoderStream,
14544  CElement * pElement);
14546 
14547 
14548 
14549  protected:
14550  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
14551 
14552  public:
14554  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14556  {
14557  return m_listImpinjAntennaPolarizationCapability.begin();
14558  }
14559 
14561  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14563  {
14564  return m_listImpinjAntennaPolarizationCapability.end();
14565  }
14566 
14568  inline void
14570  {
14571  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
14572  }
14573 
14575  inline int
14577  {
14578  return (int) (m_listImpinjAntennaPolarizationCapability.size());
14579  }
14580 
14581  EResultCode
14583  addImpinjAntennaPolarizationCapability (
14585 
14586 
14587  protected:
14588  std::list<CParameter *> m_listCustom;
14589 
14590  public:
14592  inline std::list<CParameter *>::iterator
14594  {
14595  return m_listCustom.begin();
14596  }
14597 
14599  inline std::list<CParameter *>::iterator
14600  endCustom (void)
14601  {
14602  return m_listCustom.end();
14603  }
14604 
14606  inline void
14608  {
14609  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14610  }
14611 
14613  inline int
14615  {
14616  return (int) (m_listCustom.size());
14617  }
14618 
14619  EResultCode
14621  addCustom (
14622  CParameter * pValue);
14623 
14624 
14625 };
14626 
14627 
14652 class CImpinjAntennaPolarizationCapability : public CParameter
14653 {
14654  public:
14657 
14660 
14661  static const CFieldDescriptor * const
14662  s_apFieldDescriptorTable[];
14663 
14664  static const CTypeDescriptor
14665  s_typeDescriptor;
14666 
14667  void
14668  decodeFields (
14669  CDecoderStream * pDecoderStream);
14670 
14671  void
14672  assimilateSubParameters (
14673  CErrorDetails * pError);
14674 
14675  void
14676  encode (
14677  CEncoderStream * pEncoderStream) const;
14678 
14679 
14680  llrp_bool_t
14681  isAllowedIn (
14682  const CTypeDescriptor * pEnclosingElementType) const;
14683 
14684 
14685  static CElement *
14686  s_construct (void);
14687 
14688  static void
14689  s_decodeFields (
14690  CDecoderStream * pDecoderStream,
14691  CElement * pElement);
14693 
14694 
14695  protected:
14696  EImpinjAntennaPolarizationType m_eType;
14697 
14700  public:
14701  static const CFieldDescriptor
14702  s_fdType;
14704 
14706  inline EImpinjAntennaPolarizationType
14707  getType (void)
14708  {
14709  return m_eType;
14710  }
14711 
14713  inline void
14715  EImpinjAntennaPolarizationType value)
14716  {
14717  m_eType = value;
14718  }
14719 
14720 
14721  protected:
14722  llrp_u16_t m_AntennaIDOffset;
14723 
14726  public:
14727  static const CFieldDescriptor
14728  s_fdAntennaIDOffset;
14730 
14732  inline llrp_u16_t
14734  {
14735  return m_AntennaIDOffset;
14736  }
14737 
14739  inline void
14741  llrp_u16_t value)
14742  {
14743  m_AntennaIDOffset = value;
14744  }
14745 
14746 
14747 
14748  protected:
14749  std::list<CParameter *> m_listCustom;
14750 
14751  public:
14753  inline std::list<CParameter *>::iterator
14755  {
14756  return m_listCustom.begin();
14757  }
14758 
14760  inline std::list<CParameter *>::iterator
14761  endCustom (void)
14762  {
14763  return m_listCustom.end();
14764  }
14765 
14767  inline void
14769  {
14770  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14771  }
14772 
14774  inline int
14776  {
14777  return (int) (m_listCustom.size());
14778  }
14779 
14780  EResultCode
14782  addCustom (
14783  CParameter * pValue);
14784 
14785 
14786 };
14787 
14788 
14812 class CImpinjDisabledAntennas : public CParameter
14813 {
14814  public:
14815  CImpinjDisabledAntennas (void);
14816  ~CImpinjDisabledAntennas (void);
14817 
14820 
14821  static const CFieldDescriptor * const
14822  s_apFieldDescriptorTable[];
14823 
14824  static const CTypeDescriptor
14825  s_typeDescriptor;
14826 
14827  void
14828  decodeFields (
14829  CDecoderStream * pDecoderStream);
14830 
14831  void
14832  assimilateSubParameters (
14833  CErrorDetails * pError);
14834 
14835  void
14836  encode (
14837  CEncoderStream * pEncoderStream) const;
14838 
14839 
14840  llrp_bool_t
14841  isAllowedIn (
14842  const CTypeDescriptor * pEnclosingElementType) const;
14843 
14844 
14845  static CElement *
14846  s_construct (void);
14847 
14848  static void
14849  s_decodeFields (
14850  CDecoderStream * pDecoderStream,
14851  CElement * pElement);
14853 
14854 
14855  protected:
14856  llrp_u16v_t m_AntennaIDs;
14857 
14860  public:
14861  static const CFieldDescriptor
14862  s_fdAntennaIDs;
14864 
14866  inline llrp_u16v_t
14868  {
14869  return m_AntennaIDs;
14870  }
14871 
14873  inline void
14875  llrp_u16v_t value)
14876  {
14877  m_AntennaIDs = value;
14878  }
14879 
14880 
14881 
14882  protected:
14883  std::list<CParameter *> m_listCustom;
14884 
14885  public:
14887  inline std::list<CParameter *>::iterator
14889  {
14890  return m_listCustom.begin();
14891  }
14892 
14894  inline std::list<CParameter *>::iterator
14895  endCustom (void)
14896  {
14897  return m_listCustom.end();
14898  }
14899 
14901  inline void
14903  {
14904  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14905  }
14906 
14908  inline int
14910  {
14911  return (int) (m_listCustom.size());
14912  }
14913 
14914  EResultCode
14916  addCustom (
14917  CParameter * pValue);
14918 
14919 
14920 };
14921 
14922 
14947 class CImpinjTIDParity : public CParameter
14948 {
14949  public:
14950  CImpinjTIDParity (void);
14951  ~CImpinjTIDParity (void);
14952 
14955 
14956  static const CFieldDescriptor * const
14957  s_apFieldDescriptorTable[];
14958 
14959  static const CTypeDescriptor
14960  s_typeDescriptor;
14961 
14962  void
14963  decodeFields (
14964  CDecoderStream * pDecoderStream);
14965 
14966  void
14967  assimilateSubParameters (
14968  CErrorDetails * pError);
14969 
14970  void
14971  encode (
14972  CEncoderStream * pEncoderStream) const;
14973 
14974 
14975  llrp_bool_t
14976  isAllowedIn (
14977  const CTypeDescriptor * pEnclosingElementType) const;
14978 
14979 
14980  static CElement *
14981  s_construct (void);
14982 
14983  static void
14984  s_decodeFields (
14985  CDecoderStream * pDecoderStream,
14986  CElement * pElement);
14988 
14989 
14990  protected:
14991  llrp_u1_t m_ParityError;
14992 
14995  public:
14996  static const CFieldDescriptor
14997  s_fdParityError;
14999 
15001  inline llrp_u1_t
15003  {
15004  return m_ParityError;
15005  }
15006 
15008  inline void
15010  llrp_u1_t value)
15011  {
15012  m_ParityError = value;
15013  }
15014 
15015 
15016 
15017  protected:
15018  std::list<CParameter *> m_listCustom;
15019 
15020  public:
15022  inline std::list<CParameter *>::iterator
15024  {
15025  return m_listCustom.begin();
15026  }
15027 
15029  inline std::list<CParameter *>::iterator
15030  endCustom (void)
15031  {
15032  return m_listCustom.end();
15033  }
15034 
15036  inline void
15038  {
15039  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15040  }
15041 
15043  inline int
15045  {
15046  return (int) (m_listCustom.size());
15047  }
15048 
15049  EResultCode
15051  addCustom (
15052  CParameter * pValue);
15053 
15054 
15055 };
15056 
15057 
15088 class CImpinjMarginRead : public CParameter
15089 {
15090  public:
15091  CImpinjMarginRead (void);
15092  ~CImpinjMarginRead (void);
15093 
15096 
15097  static const CFieldDescriptor * const
15098  s_apFieldDescriptorTable[];
15099 
15100  static const CTypeDescriptor
15101  s_typeDescriptor;
15102 
15103  void
15104  decodeFields (
15105  CDecoderStream * pDecoderStream);
15106 
15107  void
15108  assimilateSubParameters (
15109  CErrorDetails * pError);
15110 
15111  void
15112  encode (
15113  CEncoderStream * pEncoderStream) const;
15114 
15115 
15116  llrp_bool_t
15117  isAllowedIn (
15118  const CTypeDescriptor * pEnclosingElementType) const;
15119 
15120 
15121  static CElement *
15122  s_construct (void);
15123 
15124  static void
15125  s_decodeFields (
15126  CDecoderStream * pDecoderStream,
15127  CElement * pElement);
15129 
15130 
15131  protected:
15132  llrp_u16_t m_OpSpecID;
15133 
15136  public:
15137  static const CFieldDescriptor
15138  s_fdOpSpecID;
15140 
15142  inline llrp_u16_t
15144  {
15145  return m_OpSpecID;
15146  }
15147 
15149  inline void
15151  llrp_u16_t value)
15152  {
15153  m_OpSpecID = value;
15154  }
15155 
15156 
15157  protected:
15158  llrp_u32_t m_AccessPassword;
15159 
15162  public:
15163  static const CFieldDescriptor
15164  s_fdAccessPassword;
15166 
15168  inline llrp_u32_t
15170  {
15171  return m_AccessPassword;
15172  }
15173 
15175  inline void
15177  llrp_u32_t value)
15178  {
15179  m_AccessPassword = value;
15180  }
15181 
15182 
15183  protected:
15184  llrp_u2_t m_MB;
15185 
15188  public:
15189  static const CFieldDescriptor
15190  s_fdMB;
15192 
15194  inline llrp_u2_t
15195  getMB (void)
15196  {
15197  return m_MB;
15198  }
15199 
15201  inline void
15203  llrp_u2_t value)
15204  {
15205  m_MB = value;
15206  }
15207 
15208 
15209  protected:
15210  llrp_u16_t m_BitPointer;
15211 
15214  public:
15215  static const CFieldDescriptor
15216  s_fdBitPointer;
15218 
15220  inline llrp_u16_t
15222  {
15223  return m_BitPointer;
15224  }
15225 
15227  inline void
15229  llrp_u16_t value)
15230  {
15231  m_BitPointer = value;
15232  }
15233 
15234 
15235  protected:
15236  llrp_u8_t m_BitLength;
15237 
15240  public:
15241  static const CFieldDescriptor
15242  s_fdBitLength;
15244 
15246  inline llrp_u8_t
15248  {
15249  return m_BitLength;
15250  }
15251 
15253  inline void
15255  llrp_u8_t value)
15256  {
15257  m_BitLength = value;
15258  }
15259 
15260 
15261  protected:
15262  llrp_u16v_t m_Mask;
15263 
15266  public:
15267  static const CFieldDescriptor
15268  s_fdMask;
15270 
15272  inline llrp_u16v_t
15273  getMask (void)
15274  {
15275  return m_Mask;
15276  }
15277 
15279  inline void
15281  llrp_u16v_t value)
15282  {
15283  m_Mask = value;
15284  }
15285 
15286 
15287 
15288  protected:
15289  std::list<CParameter *> m_listCustom;
15290 
15291  public:
15293  inline std::list<CParameter *>::iterator
15295  {
15296  return m_listCustom.begin();
15297  }
15298 
15300  inline std::list<CParameter *>::iterator
15301  endCustom (void)
15302  {
15303  return m_listCustom.end();
15304  }
15305 
15307  inline void
15309  {
15310  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15311  }
15312 
15314  inline int
15316  {
15317  return (int) (m_listCustom.size());
15318  }
15319 
15320  EResultCode
15322  addCustom (
15323  CParameter * pValue);
15324 
15325 
15326 };
15327 
15328 
15354 class CImpinjMarginReadOpSpecResult : public CParameter
15355 {
15356  public:
15359 
15362 
15363  static const CFieldDescriptor * const
15364  s_apFieldDescriptorTable[];
15365 
15366  static const CTypeDescriptor
15367  s_typeDescriptor;
15368 
15369  void
15370  decodeFields (
15371  CDecoderStream * pDecoderStream);
15372 
15373  void
15374  assimilateSubParameters (
15375  CErrorDetails * pError);
15376 
15377  void
15378  encode (
15379  CEncoderStream * pEncoderStream) const;
15380 
15381 
15382  llrp_bool_t
15383  isAllowedIn (
15384  const CTypeDescriptor * pEnclosingElementType) const;
15385 
15386 
15387  static CElement *
15388  s_construct (void);
15389 
15390  static void
15391  s_decodeFields (
15392  CDecoderStream * pDecoderStream,
15393  CElement * pElement);
15395 
15396 
15397  protected:
15398  EImpinjMarginReadResultType m_eResult;
15399 
15402  public:
15403  static const CFieldDescriptor
15404  s_fdResult;
15406 
15408  inline EImpinjMarginReadResultType
15409  getResult (void)
15410  {
15411  return m_eResult;
15412  }
15413 
15415  inline void
15417  EImpinjMarginReadResultType value)
15418  {
15419  m_eResult = value;
15420  }
15421 
15422 
15423  protected:
15424  llrp_u16_t m_OpSpecID;
15425 
15428  public:
15429  static const CFieldDescriptor
15430  s_fdOpSpecID;
15432 
15434  inline llrp_u16_t
15436  {
15437  return m_OpSpecID;
15438  }
15439 
15441  inline void
15443  llrp_u16_t value)
15444  {
15445  m_OpSpecID = value;
15446  }
15447 
15448 
15449 
15450  protected:
15451  std::list<CParameter *> m_listCustom;
15452 
15453  public:
15455  inline std::list<CParameter *>::iterator
15457  {
15458  return m_listCustom.begin();
15459  }
15460 
15462  inline std::list<CParameter *>::iterator
15463  endCustom (void)
15464  {
15465  return m_listCustom.end();
15466  }
15467 
15469  inline void
15471  {
15472  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15473  }
15474 
15476  inline int
15478  {
15479  return (int) (m_listCustom.size());
15480  }
15481 
15482  EResultCode
15484  addCustom (
15485  CParameter * pValue);
15486 
15487 
15488 };
15489 
15490 
15515 class CImpinjBLEVersion : public CParameter
15516 {
15517  public:
15518  CImpinjBLEVersion (void);
15519  ~CImpinjBLEVersion (void);
15520 
15523 
15524  static const CFieldDescriptor * const
15525  s_apFieldDescriptorTable[];
15526 
15527  static const CTypeDescriptor
15528  s_typeDescriptor;
15529 
15530  void
15531  decodeFields (
15532  CDecoderStream * pDecoderStream);
15533 
15534  void
15535  assimilateSubParameters (
15536  CErrorDetails * pError);
15537 
15538  void
15539  encode (
15540  CEncoderStream * pEncoderStream) const;
15541 
15542 
15543  llrp_bool_t
15544  isAllowedIn (
15545  const CTypeDescriptor * pEnclosingElementType) const;
15546 
15547 
15548  static CElement *
15549  s_construct (void);
15550 
15551  static void
15552  s_decodeFields (
15553  CDecoderStream * pDecoderStream,
15554  CElement * pElement);
15556 
15557 
15558  protected:
15559  llrp_utf8v_t m_FirmwareVersion;
15560 
15563  public:
15564  static const CFieldDescriptor
15565  s_fdFirmwareVersion;
15567 
15569  inline llrp_utf8v_t
15571  {
15572  return m_FirmwareVersion;
15573  }
15574 
15576  inline void
15578  llrp_utf8v_t value)
15579  {
15580  m_FirmwareVersion = value;
15581  }
15582 
15583 
15584 
15585  protected:
15586  std::list<CParameter *> m_listCustom;
15587 
15588  public:
15590  inline std::list<CParameter *>::iterator
15592  {
15593  return m_listCustom.begin();
15594  }
15595 
15597  inline std::list<CParameter *>::iterator
15598  endCustom (void)
15599  {
15600  return m_listCustom.end();
15601  }
15602 
15604  inline void
15606  {
15607  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15608  }
15609 
15611  inline int
15613  {
15614  return (int) (m_listCustom.size());
15615  }
15616 
15617  EResultCode
15619  addCustom (
15620  CParameter * pValue);
15621 
15622 
15623 };
15624 
15625 
15649 class CImpinjLocationAlgorithmControl : public CParameter
15650 {
15651  public:
15654 
15657 
15658  static const CFieldDescriptor * const
15659  s_apFieldDescriptorTable[];
15660 
15661  static const CTypeDescriptor
15662  s_typeDescriptor;
15663 
15664  void
15665  decodeFields (
15666  CDecoderStream * pDecoderStream);
15667 
15668  void
15669  assimilateSubParameters (
15670  CErrorDetails * pError);
15671 
15672  void
15673  encode (
15674  CEncoderStream * pEncoderStream) const;
15675 
15676 
15677  llrp_bool_t
15678  isAllowedIn (
15679  const CTypeDescriptor * pEnclosingElementType) const;
15680 
15681 
15682  static CElement *
15683  s_construct (void);
15684 
15685  static void
15686  s_decodeFields (
15687  CDecoderStream * pDecoderStream,
15688  CElement * pElement);
15690 
15691 
15692  protected:
15693  llrp_u32v_t m_ControlData;
15694 
15697  public:
15698  static const CFieldDescriptor
15699  s_fdControlData;
15701 
15703  inline llrp_u32v_t
15705  {
15706  return m_ControlData;
15707  }
15708 
15710  inline void
15712  llrp_u32v_t value)
15713  {
15714  m_ControlData = value;
15715  }
15716 
15717 
15718 
15719  protected:
15720  std::list<CParameter *> m_listCustom;
15721 
15722  public:
15724  inline std::list<CParameter *>::iterator
15726  {
15727  return m_listCustom.begin();
15728  }
15729 
15731  inline std::list<CParameter *>::iterator
15732  endCustom (void)
15733  {
15734  return m_listCustom.end();
15735  }
15736 
15738  inline void
15740  {
15741  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15742  }
15743 
15745  inline int
15747  {
15748  return (int) (m_listCustom.size());
15749  }
15750 
15751  EResultCode
15753  addCustom (
15754  CParameter * pValue);
15755 
15756 
15757 };
15758 
15759 
15796 class CImpinjRFPowerSweep : public CParameter
15797 {
15798  public:
15799  CImpinjRFPowerSweep (void);
15800  ~CImpinjRFPowerSweep (void);
15801 
15804 
15805  static const CFieldDescriptor * const
15806  s_apFieldDescriptorTable[];
15807 
15808  static const CTypeDescriptor
15809  s_typeDescriptor;
15810 
15811  void
15812  decodeFields (
15813  CDecoderStream * pDecoderStream);
15814 
15815  void
15816  assimilateSubParameters (
15817  CErrorDetails * pError);
15818 
15819  void
15820  encode (
15821  CEncoderStream * pEncoderStream) const;
15822 
15823 
15824  llrp_bool_t
15825  isAllowedIn (
15826  const CTypeDescriptor * pEnclosingElementType) const;
15827 
15828 
15829  static CElement *
15830  s_construct (void);
15831 
15832  static void
15833  s_decodeFields (
15834  CDecoderStream * pDecoderStream,
15835  CElement * pElement);
15837 
15838 
15839  protected:
15840  llrp_u1_t m_EnableRFPowerSweep;
15841 
15844  public:
15845  static const CFieldDescriptor
15846  s_fdEnableRFPowerSweep;
15848 
15850  inline llrp_u1_t
15852  {
15853  return m_EnableRFPowerSweep;
15854  }
15855 
15857  inline void
15859  llrp_u1_t value)
15860  {
15861  m_EnableRFPowerSweep = value;
15862  }
15863 
15864 
15865  protected:
15866  llrp_u16_t m_MinimumPowerLevel;
15867 
15870  public:
15871  static const CFieldDescriptor
15872  s_fdMinimumPowerLevel;
15874 
15876  inline llrp_u16_t
15878  {
15879  return m_MinimumPowerLevel;
15880  }
15881 
15883  inline void
15885  llrp_u16_t value)
15886  {
15887  m_MinimumPowerLevel = value;
15888  }
15889 
15890 
15891  protected:
15892  llrp_u16_t m_PowerLevelStepSize;
15893 
15896  public:
15897  static const CFieldDescriptor
15898  s_fdPowerLevelStepSize;
15900 
15902  inline llrp_u16_t
15904  {
15905  return m_PowerLevelStepSize;
15906  }
15907 
15909  inline void
15911  llrp_u16_t value)
15912  {
15913  m_PowerLevelStepSize = value;
15914  }
15915 
15916 
15917 
15918  protected:
15919  std::list<CParameter *> m_listCustom;
15920 
15921  public:
15923  inline std::list<CParameter *>::iterator
15925  {
15926  return m_listCustom.begin();
15927  }
15928 
15930  inline std::list<CParameter *>::iterator
15931  endCustom (void)
15932  {
15933  return m_listCustom.end();
15934  }
15935 
15937  inline void
15939  {
15940  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15941  }
15942 
15944  inline int
15946  {
15947  return (int) (m_listCustom.size());
15948  }
15949 
15950  EResultCode
15952  addCustom (
15953  CParameter * pValue);
15954 
15955 
15956 };
15957 
15958 
15999 class CImpinjTruncatedReplyConfiguration : public CParameter
16000 {
16001  public:
16004 
16007 
16008  static const CFieldDescriptor * const
16009  s_apFieldDescriptorTable[];
16010 
16011  static const CTypeDescriptor
16012  s_typeDescriptor;
16013 
16014  void
16015  decodeFields (
16016  CDecoderStream * pDecoderStream);
16017 
16018  void
16019  assimilateSubParameters (
16020  CErrorDetails * pError);
16021 
16022  void
16023  encode (
16024  CEncoderStream * pEncoderStream) const;
16025 
16026 
16027  llrp_bool_t
16028  isAllowedIn (
16029  const CTypeDescriptor * pEnclosingElementType) const;
16030 
16031 
16032  static CElement *
16033  s_construct (void);
16034 
16035  static void
16036  s_decodeFields (
16037  CDecoderStream * pDecoderStream,
16038  CElement * pElement);
16040 
16041 
16042  protected:
16043  llrp_u1_t m_Gen2v2TagsOnly;
16044 
16047  public:
16048  static const CFieldDescriptor
16049  s_fdGen2v2TagsOnly;
16051 
16053  inline llrp_u1_t
16055  {
16056  return m_Gen2v2TagsOnly;
16057  }
16058 
16060  inline void
16062  llrp_u1_t value)
16063  {
16064  m_Gen2v2TagsOnly = value;
16065  }
16066 
16067 
16068  protected:
16069  llrp_u8_t m_EPCLength;
16070 
16073  public:
16074  static const CFieldDescriptor
16075  s_fdEPCLength;
16077 
16079  inline llrp_u8_t
16081  {
16082  return m_EPCLength;
16083  }
16084 
16086  inline void
16088  llrp_u8_t value)
16089  {
16090  m_EPCLength = value;
16091  }
16092 
16093 
16094  protected:
16095  llrp_u16_t m_Pointer;
16096 
16099  public:
16100  static const CFieldDescriptor
16101  s_fdPointer;
16103 
16105  inline llrp_u16_t
16106  getPointer (void)
16107  {
16108  return m_Pointer;
16109  }
16110 
16112  inline void
16114  llrp_u16_t value)
16115  {
16116  m_Pointer = value;
16117  }
16118 
16119 
16120  protected:
16121  llrp_u1v_t m_TagMask;
16122 
16125  public:
16126  static const CFieldDescriptor
16127  s_fdTagMask;
16129 
16131  inline llrp_u1v_t
16132  getTagMask (void)
16133  {
16134  return m_TagMask;
16135  }
16136 
16138  inline void
16140  llrp_u1v_t value)
16141  {
16142  m_TagMask = value;
16143  }
16144 
16145 
16146 
16147  protected:
16148  std::list<CParameter *> m_listCustom;
16149 
16150  public:
16152  inline std::list<CParameter *>::iterator
16154  {
16155  return m_listCustom.begin();
16156  }
16157 
16159  inline std::list<CParameter *>::iterator
16160  endCustom (void)
16161  {
16162  return m_listCustom.end();
16163  }
16164 
16166  inline void
16168  {
16169  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16170  }
16171 
16173  inline int
16175  {
16176  return (int) (m_listCustom.size());
16177  }
16178 
16179  EResultCode
16181  addCustom (
16182  CParameter * pValue);
16183 
16184 
16185 };
16186 
16187 
16233 class CImpinjAuthenticate : public CParameter
16234 {
16235  public:
16236  CImpinjAuthenticate (void);
16237  ~CImpinjAuthenticate (void);
16238 
16241 
16242  static const CFieldDescriptor * const
16243  s_apFieldDescriptorTable[];
16244 
16245  static const CTypeDescriptor
16246  s_typeDescriptor;
16247 
16248  void
16249  decodeFields (
16250  CDecoderStream * pDecoderStream);
16251 
16252  void
16253  assimilateSubParameters (
16254  CErrorDetails * pError);
16255 
16256  void
16257  encode (
16258  CEncoderStream * pEncoderStream) const;
16259 
16260 
16261  llrp_bool_t
16262  isAllowedIn (
16263  const CTypeDescriptor * pEnclosingElementType) const;
16264 
16265 
16266  static CElement *
16267  s_construct (void);
16268 
16269  static void
16270  s_decodeFields (
16271  CDecoderStream * pDecoderStream,
16272  CElement * pElement);
16274 
16275 
16276  protected:
16277  llrp_u16_t m_OpSpecID;
16278 
16281  public:
16282  static const CFieldDescriptor
16283  s_fdOpSpecID;
16285 
16287  inline llrp_u16_t
16289  {
16290  return m_OpSpecID;
16291  }
16292 
16294  inline void
16296  llrp_u16_t value)
16297  {
16298  m_OpSpecID = value;
16299  }
16300 
16301 
16302  protected:
16303  llrp_u32_t m_AccessPassword;
16304 
16307  public:
16308  static const CFieldDescriptor
16309  s_fdAccessPassword;
16311 
16313  inline llrp_u32_t
16315  {
16316  return m_AccessPassword;
16317  }
16318 
16320  inline void
16322  llrp_u32_t value)
16323  {
16324  m_AccessPassword = value;
16325  }
16326 
16327 
16328  protected:
16329  llrp_u1_t m_SendRep;
16330 
16333  public:
16334  static const CFieldDescriptor
16335  s_fdSendRep;
16337 
16339  inline llrp_u1_t
16340  getSendRep (void)
16341  {
16342  return m_SendRep;
16343  }
16344 
16346  inline void
16348  llrp_u1_t value)
16349  {
16350  m_SendRep = value;
16351  }
16352 
16353 
16354  protected:
16355  llrp_u1_t m_IncRepLen;
16356 
16359  public:
16360  static const CFieldDescriptor
16361  s_fdIncRepLen;
16363 
16365  inline llrp_u1_t
16367  {
16368  return m_IncRepLen;
16369  }
16370 
16372  inline void
16374  llrp_u1_t value)
16375  {
16376  m_IncRepLen = value;
16377  }
16378 
16379 
16380  protected:
16381  llrp_u8_t m_CSI;
16382 
16385  public:
16386  static const CFieldDescriptor
16387  s_fdCSI;
16389 
16391  inline llrp_u8_t
16392  getCSI (void)
16393  {
16394  return m_CSI;
16395  }
16396 
16398  inline void
16400  llrp_u8_t value)
16401  {
16402  m_CSI = value;
16403  }
16404 
16405 
16406  protected:
16407  llrp_u1v_t m_Message;
16408 
16411  public:
16412  static const CFieldDescriptor
16413  s_fdMessage;
16415 
16417  inline llrp_u1v_t
16418  getMessage (void)
16419  {
16420  return m_Message;
16421  }
16422 
16424  inline void
16426  llrp_u1v_t value)
16427  {
16428  m_Message = value;
16429  }
16430 
16431 
16432 
16433  protected:
16434  std::list<CParameter *> m_listCustom;
16435 
16436  public:
16438  inline std::list<CParameter *>::iterator
16440  {
16441  return m_listCustom.begin();
16442  }
16443 
16445  inline std::list<CParameter *>::iterator
16446  endCustom (void)
16447  {
16448  return m_listCustom.end();
16449  }
16450 
16452  inline void
16454  {
16455  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16456  }
16457 
16459  inline int
16461  {
16462  return (int) (m_listCustom.size());
16463  }
16464 
16465  EResultCode
16467  addCustom (
16468  CParameter * pValue);
16469 
16470 
16471 };
16472 
16473 
16503 class CImpinjAuthenticateOpSpecResult : public CParameter
16504 {
16505  public:
16508 
16511 
16512  static const CFieldDescriptor * const
16513  s_apFieldDescriptorTable[];
16514 
16515  static const CTypeDescriptor
16516  s_typeDescriptor;
16517 
16518  void
16519  decodeFields (
16520  CDecoderStream * pDecoderStream);
16521 
16522  void
16523  assimilateSubParameters (
16524  CErrorDetails * pError);
16525 
16526  void
16527  encode (
16528  CEncoderStream * pEncoderStream) const;
16529 
16530 
16531  llrp_bool_t
16532  isAllowedIn (
16533  const CTypeDescriptor * pEnclosingElementType) const;
16534 
16535 
16536  static CElement *
16537  s_construct (void);
16538 
16539  static void
16540  s_decodeFields (
16541  CDecoderStream * pDecoderStream,
16542  CElement * pElement);
16544 
16545 
16546  protected:
16547  EImpinjAuthenticateResultType m_eResult;
16548 
16551  public:
16552  static const CFieldDescriptor
16553  s_fdResult;
16555 
16557  inline EImpinjAuthenticateResultType
16558  getResult (void)
16559  {
16560  return m_eResult;
16561  }
16562 
16564  inline void
16566  EImpinjAuthenticateResultType value)
16567  {
16568  m_eResult = value;
16569  }
16570 
16571 
16572  protected:
16573  llrp_u16_t m_OpSpecID;
16574 
16577  public:
16578  static const CFieldDescriptor
16579  s_fdOpSpecID;
16581 
16583  inline llrp_u16_t
16585  {
16586  return m_OpSpecID;
16587  }
16588 
16590  inline void
16592  llrp_u16_t value)
16593  {
16594  m_OpSpecID = value;
16595  }
16596 
16597 
16598  protected:
16599  llrp_u1v_t m_Response;
16600 
16603  public:
16604  static const CFieldDescriptor
16605  s_fdResponse;
16607 
16609  inline llrp_u1v_t
16611  {
16612  return m_Response;
16613  }
16614 
16616  inline void
16618  llrp_u1v_t value)
16619  {
16620  m_Response = value;
16621  }
16622 
16623 
16624 
16625  protected:
16626  std::list<CParameter *> m_listCustom;
16627 
16628  public:
16630  inline std::list<CParameter *>::iterator
16632  {
16633  return m_listCustom.begin();
16634  }
16635 
16637  inline std::list<CParameter *>::iterator
16638  endCustom (void)
16639  {
16640  return m_listCustom.end();
16641  }
16642 
16644  inline void
16646  {
16647  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16648  }
16649 
16651  inline int
16653  {
16654  return (int) (m_listCustom.size());
16655  }
16656 
16657  EResultCode
16659  addCustom (
16660  CParameter * pValue);
16661 
16662 
16663 };
16664 
16665 
16680 extern void
16682  CTypeRegistry * pTypeRegistry);
CImpinjOpSpecRetryCount * getImpinjOpSpecRetryCount(void)
Get accessor functions for the LLRP ImpinjOpSpecRetryCount sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLowDutyCycleMode getLowDutyCycleMode(void)
Get accessor functions for the LLRP LowDutyCycleMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAccessSpecOrderingMode getOrderingMode(void)
Get accessor functions for the LLRP OrderingMode field.
void setSystemTagPopulationLimitHighSensitivity(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjTagReportContentSelector for LLRP parameter ImpinjTagReportContentSelector.
llrp_u16_t getGPOPortNum(void)
Get accessor functions for the LLRP GPOPortNum field.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
Class Definition CImpinjPlacementConfiguration for LLRP parameter ImpinjPlacementConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjIntelligentAntennaManagement for LLRP parameter ImpinjIntelligentAntennaManag...
CImpinjHubVersions * getImpinjHubVersions(void)
Get accessor functions for the LLRP ImpinjHubVersions sub-parameter.
llrp_utf8v_t getRMCSentence(void)
Get accessor functions for the LLRP RMCSentence field.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16_t getRetryCount(void)
Get accessor functions for the LLRP RetryCount field.
llrp_u1_t getParityError(void)
Get accessor functions for the LLRP ParityError field.
CImpinjArrayVersion * getImpinjArrayVersion(void)
Get accessor functions for the LLRP ImpinjArrayVersion sub-parameter.
Class Definition CImpinjGetQTConfigOpSpecResult for LLRP parameter ImpinjGetQTConfigOpSpecResult.
void setTxPower(llrp_u16_t value)
Set accessor functions for the LLRP TxPower field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setFieldOfView(EImpinjDirectionFieldOfView value)
Set accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getBeaconState(void)
Get accessor functions for the LLRP BeaconState field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s32_t getFacilityYLocationCm(void)
Get accessor functions for the LLRP FacilityYLocationCm field.
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjInventoryConfiguration for LLRP parameter ImpinjInventoryConfiguration.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubConnectedType getConnected(void)
Get accessor functions for the LLRP Connected field.
llrp_u16_t getBitPointer(void)
Get accessor functions for the LLRP BitPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setType(EImpinjAntennaPolarizationType value)
Set accessor functions for the LLRP Type field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLoopSpec for LLRP parameter ImpinjLoopSpec.
Class Definition CImpinjSubRegulatoryRegion for LLRP parameter ImpinjSubRegulatoryRegion.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjTransmitPower for LLRP parameter ImpinjTransmitPower.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getControlData(void)
Get accessor functions for the LLRP ControlData field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getLastSeenSectorID(void)
Get accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConnected(EImpinjHubConnectedType value)
Set accessor functions for the LLRP Connected field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModelName(llrp_utf8v_t value)
Set accessor functions for the LLRP ModelName field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setBeaconState(llrp_u1_t value)
Set accessor functions for the LLRP BeaconState field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjFixedFrequencyList for LLRP parameter ImpinjFixedFrequencyList.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CIMPINJ_ENABLE_EXTENSIONS_RESPONSE for LLRP message IMPINJ_ENABLE_EXTENSIONS_RESPONS...
Class Definition CImpinjTiltConfiguration for LLRP parameter ImpinjTiltConfiguration.
llrp_u16v_t getTID(void)
Get accessor functions for the LLRP TID field.
void setSupportsTISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTISpecs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
llrp_s32_t getZAxis(void)
Get accessor functions for the LLRP ZAxis field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getReadCount(void)
Get accessor functions for the LLRP ReadCount field.
void setRFMode(EImpinjDirectionRFMode value)
Set accessor functions for the LLRP RFMode field.
void setResult(EImpinjMarginReadResultType value)
Set accessor functions for the LLRP Result field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
CImpinjEnableRFPhaseAngle * getImpinjEnableRFPhaseAngle(void)
Get accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearImpinjArrayVersion(void)
Clears the LLRP ImpinjArrayVersion sub-parameter list.
EImpinjDirectionFieldOfView getFieldOfView(void)
Get accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEnableAntennaAttemptNotification(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaAttemptNotification field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16v_t getEnabledSectorIDs(void)
Get accessor functions for the LLRP EnabledSectorIDs field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaEventDisconnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventDisconnected field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjRFPowerSweep for LLRP parameter ImpinjRFPowerSweep.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRFDopplerFrequencyMode(EImpinjRFDopplerFrequencyMode value)
Set accessor functions for the LLRP RFDopplerFrequencyMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
Class Definition CImpinjAntennaPolarizationCapability for LLRP parameter ImpinjAntennaPolarizationCap...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
CImpinjGGASentence * getImpinjGGASentence(void)
Get accessor functions for the LLRP ImpinjGGASentence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSupportsDISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsDISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjReducedPowerMode getReducedPowerMode(void)
Get accessor functions for the LLRP ReducedPowerMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjDisabledAntennas * getImpinjDisabledAntennas(void)
Get accessor functions for the LLRP ImpinjDisabledAntennas sub-parameter.
void setResult(EImpinjGetBlockPermalockStatusResultType value)
Set accessor functions for the LLRP Result field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjTxPower for LLRP parameter ImpinjTxPower.
llrp_u16_t getUserTagPopulationLimit(void)
Get accessor functions for the LLRP UserTagPopulationLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLocationAlgorithmControl for LLRP parameter ImpinjLocationAlgorithmControl.
void setMaxNumSectors(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSectors field.
void setXAxis(llrp_s32_t value)
Set accessor functions for the LLRP XAxis field.
llrp_u8_t getFirstSeenSectorID(void)
Get accessor functions for the LLRP FirstSeenSectorID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjLISpec for LLRP parameter ImpinjLISpec.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
llrp_u1_t getEnableAntennaAttemptNotification(void)
Get accessor functions for the LLRP EnableAntennaAttemptNotification field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjBLEVersion for LLRP parameter ImpinjBLEVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setSendRep(llrp_u1_t value)
Set accessor functions for the LLRP SendRep field.
EImpinjAuthenticateResultType getResult(void)
Get accessor functions for the LLRP Result field.
Class Definition CImpinjLocationReportData for LLRP parameter ImpinjLocationReportData.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLinkMonitorMode getLinkMonitorMode(void)
Get accessor functions for the LLRP LinkMonitorMode field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setTxPowerReportingMode(EImpinjTxPowerReportingModeEnum value)
Set accessor functions for the LLRP TxPowerReportingMode field.
void setGPIDebounceTimerMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPIDebounceTimerMSec field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getEnableRFPowerSweep(void)
Get accessor functions for the LLRP EnableRFPowerSweep field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFPhaseAngleMode getRFPhaseAngleMode(void)
Get accessor functions for the LLRP RFPhaseAngleMode field.
EImpinjTxPowerReportingModeEnum getTxPowerReportingMode(void)
Get accessor functions for the LLRP TxPowerReportingMode field.
Class Definition CImpinjDirectionConfig for LLRP parameter ImpinjDirectionConfig. ...
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjGetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPolarizationControl for LLRP parameter ImpinjPolarizationControl.
void setFixedFrequencyMode(EImpinjFixedFrequencyMode value)
Set accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjReportBufferConfiguration for LLRP parameter ImpinjReportBufferConfiguration...
void enrollImpinjTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Impinj into the LTKCPP registry.
llrp_u16_t getPowerLevelStepSize(void)
Get accessor functions for the LLRP PowerLevelStepSize field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnableSelectGapClose(llrp_u1_t value)
Set accessor functions for the LLRP EnableSelectGapClose field.
void setFacilityYLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityYLocationCm field.
CImpinjDirectionReporting * getImpinjDirectionReporting(void)
Get accessor functions for the LLRP ImpinjDirectionReporting sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setReadCount(llrp_u16_t value)
Set accessor functions for the LLRP ReadCount field.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaEventHysteresis for LLRP parameter ImpinjAntennaEventHysteresis.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLowDutyCycle for LLRP parameter ImpinjLowDutyCycle.
void setPhaseAngle(llrp_u16_t value)
Set accessor functions for the LLRP PhaseAngle field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode
Error result codes for LTK operations.
Definition: ltkcpp_base.h:583
EImpinjDirectionReportType getType(void)
Get accessor functions for the LLRP Type field.
void setMask(llrp_u16v_t value)
Set accessor functions for the LLRP Mask field.
std::list< CImpinjArrayVersion * >::iterator beginImpinjArrayVersion(void)
Returns the first element of the ImpinjArrayVersion sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAuthenticate for LLRP parameter ImpinjAuthenticate.
void setFacilityXLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityXLocationCm field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjTIDParity * getImpinjTIDParity(void)
Get accessor functions for the LLRP ImpinjTIDParity sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPeakRSSI for LLRP parameter ImpinjPeakRSSI.
CImpinjLocationReportData * getImpinjLocationReportData(void)
Get accessor functions for the LLRP ImpinjLocationReportData sub-parameter.
llrp_u16_t getEmptyFieldTimeout(void)
Get accessor functions for the LLRP EmptyFieldTimeout field.
void setYAxis(llrp_s32_t value)
Set accessor functions for the LLRP YAxis field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAdvancedGPOMode getGPOMode(void)
Get accessor functions for the LLRP GPOMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setRMCSentence(llrp_utf8v_t value)
Set accessor functions for the LLRP RMCSentence field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjBlockPermalockResultType value)
Set accessor functions for the LLRP Result field.
CImpinjDirectionReportData * getImpinjDirectionReportData(void)
Get accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void setZAxis(llrp_s32_t value)
Set accessor functions for the LLRP ZAxis field.
llrp_u32_t getGPOPulseDurationMSec(void)
Get accessor functions for the LLRP GPOPulseDurationMSec field.
void setReportBufferMode(EImpinjReportBufferMode value)
Set accessor functions for the LLRP ReportBufferMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjBlockWriteWordCount for LLRP parameter ImpinjBlockWriteWordCount.
void setFirstSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP FirstSeenTimestampUTC field.
void setLongitude(llrp_s32_t value)
Set accessor functions for the LLRP Longitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator beginImpinjAntennaPolarizationCapability(void)
Returns the first element of the ImpinjAntennaPolarizationCapability sub-parameter list...
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
CImpinjDirectionUserTagPopulationLimit * getImpinjDirectionUserTagPopulationLimit(void)
Get accessor functions for the LLRP ImpinjDirectionUserTagPopulationLimit sub-parameter.
Class Definition CImpinjGGASentence for LLRP parameter ImpinjGGASentence.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getSystemTagPopulationLimitHighPerformance(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
Class Definition CImpinjLocationReporting for LLRP parameter ImpinjLocationReporting.
Class Definition CImpinjDisabledAntennas for LLRP parameter ImpinjDisabledAntennas.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjRFPhaseAngle for LLRP parameter ImpinjRFPhaseAngle.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearC1G2Read(void)
Clears the LLRP C1G2Read sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s16_t getTemperature(void)
Get accessor functions for the LLRP Temperature field.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS for LLRP message IMPINJ_SAVE_SETTINGS.
void setPolarizationControlEnabled(llrp_u1_t value)
Set accessor functions for the LLRP PolarizationControlEnabled field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getGen2v2TagsOnly(void)
Get accessor functions for the LLRP Gen2v2TagsOnly field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u1_t getSendRep(void)
Get accessor functions for the LLRP SendRep field.
void setRFPhaseAngleMode(EImpinjRFPhaseAngleMode value)
Set accessor functions for the LLRP RFPhaseAngleMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setResult(EImpinjGetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjEnablePeakRSSI for LLRP parameter ImpinjEnablePeakRSSI.
Class Definition CImpinjBeaconConfiguration for LLRP parameter ImpinjBeaconConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setLinkDownThreshold(llrp_u16_t value)
Set accessor functions for the LLRP LinkDownThreshold field.
Class Definition CImpinjGPSNMEASentences for LLRP parameter ImpinjGPSNMEASentences.
Class Definition CImpinjDiagnosticReport for LLRP parameter ImpinjDiagnosticReport.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjDirectionTagPopulationStatus getTagPopulationStatus(void)
Get accessor functions for the LLRP TagPopulationStatus field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setPersistence(EImpinjQTPersistence value)
Set accessor functions for the LLRP Persistence field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocYCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
llrp_u32v_t getConfidenceData(void)
Get accessor functions for the LLRP ConfidenceData field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLowDutyCycleMode(EImpinjLowDutyCycleMode value)
Set accessor functions for the LLRP LowDutyCycleMode field.
llrp_u16v_t getMask(void)
Get accessor functions for the LLRP Mask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjIntelligentAntennaMode getManagementEnabled(void)
Get accessor functions for the LLRP ManagementEnabled field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjxArrayCapabilities for LLRP parameter ImpinjxArrayCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjBlockPermalockOpSpecResult for LLRP parameter ImpinjBlockPermalockOpSpecResul...
CImpinjRMCSentence * getImpinjRMCSentence(void)
Get accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjArrayVersion for LLRP parameter ImpinjArrayVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getMinimumPowerLevel(void)
Get accessor functions for the LLRP MinimumPowerLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjBlockPermalock for LLRP parameter ImpinjBlockPermalock.
void setBitPointer(llrp_u16_t value)
Set accessor functions for the LLRP BitPointer field.
llrp_u64_t getAntennaEventConnected(void)
Get accessor functions for the LLRP AntennaEventConnected field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
llrp_u1_t getSupportsTISpecs(void)
Get accessor functions for the LLRP SupportsTISpecs field.
Class Definition CImpinjInventorySearchMode for LLRP parameter ImpinjInventorySearchMode.
llrp_u16_t getSystemTagPopulationLimitHighSensitivity(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjSetQTConfig for LLRP parameter ImpinjSetQTConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
void setGen2v2TagsOnly(llrp_u1_t value)
Set accessor functions for the LLRP Gen2v2TagsOnly field.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
Class Definition CImpinjAuthenticateOpSpecResult for LLRP parameter ImpinjAuthenticateOpSpecResult.
void setDopplerFrequency(llrp_s16_t value)
Set accessor functions for the LLRP DopplerFrequency field.
void setEnableRFPowerSweep(llrp_u1_t value)
Set accessor functions for the LLRP EnableRFPowerSweep field.
llrp_u16v_t getPermalockStatus(void)
Get accessor functions for the LLRP PermalockStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setHeightCm(llrp_u16_t value)
Set accessor functions for the LLRP HeightCm field.
llrp_u1_t getSupportsDISpecs(void)
Get accessor functions for the LLRP SupportsDISpecs field.
void setResult(EImpinjAuthenticateResultType value)
Set accessor functions for the LLRP Result field.
void setCSI(llrp_u8_t value)
Set accessor functions for the LLRP CSI field.
llrp_u32_t getMaxNumSectors(void)
Get accessor functions for the LLRP MaxNumSectors field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setInventorySearchMode(EImpinjInventorySearchType value)
Set accessor functions for the LLRP InventorySearchMode field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjRequestedDataType getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void setControlData(llrp_u32v_t value)
Set accessor functions for the LLRP ControlData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
void setAntennaIDOffset(llrp_u16_t value)
Set accessor functions for the LLRP AntennaIDOffset field.
void setFPGAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FPGAVersion field.
void setLatitude(llrp_s32_t value)
Set accessor functions for the LLRP Latitude field.
void setRequestedData(EImpinjRequestedDataType value)
Set accessor functions for the LLRP RequestedData field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getBitLength(void)
Get accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setEnableAntDwellTimeLimit(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntDwellTimeLimit field.
Class Definition CEPCData for LLRP parameter EPCData.
llrp_u16_t getComputeWindowSeconds(void)
Get accessor functions for the LLRP ComputeWindowSeconds field.
void setType(EImpinjLocationReportType value)
Set accessor functions for the LLRP Type field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s16_t getDopplerFrequency(void)
Get accessor functions for the LLRP DopplerFrequency field.
Class Definition CImpinjTruncatedReplyConfiguration for LLRP parameter ImpinjTruncatedReplyConfigurat...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void setPowerLevelStepSize(llrp_u16_t value)
Set accessor functions for the LLRP PowerLevelStepSize field.
EImpinjMarginReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaIDOffset(void)
Get accessor functions for the LLRP AntennaIDOffset field.
void setGPOMode(EImpinjAdvancedGPOMode value)
Set accessor functions for the LLRP GPOMode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
llrp_u1v_t getMessage(void)
Get accessor functions for the LLRP Message field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
Class Definition CImpinjEnableTxPower for LLRP parameter ImpinjEnableTxPower.
llrp_u16_t getFieldPingInterval(void)
Get accessor functions for the LLRP FieldPingInterval field.
Class Definition CImpinjEnableSerializedTID for LLRP parameter ImpinjEnableSerializedTID.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
llrp_u16_t getTxPower(void)
Get accessor functions for the LLRP TxPower field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHubID(void)
Get accessor functions for the LLRP HubID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrderingMode(EImpinjAccessSpecOrderingMode value)
Set accessor functions for the LLRP OrderingMode field.
llrp_u16_t getPhaseAngle(void)
Get accessor functions for the LLRP PhaseAngle field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
CImpinjC1G2DirectionConfig * getImpinjC1G2DirectionConfig(void)
Get accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
llrp_u16_t getBlockRange(void)
Get accessor functions for the LLRP BlockRange field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator endImpinjAntennaPolarizationCapability(void)
Returns the last element of the ImpinjAntennaPolarizationCapability sub-parameter list...
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_u1_t getPolarizationControlEnabled(void)
Get accessor functions for the LLRP PolarizationControlEnabled field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRSSI(llrp_s16_t value)
Set accessor functions for the LLRP RSSI field.
Class Definition CImpinjDetailedVersion for LLRP parameter ImpinjDetailedVersion. ...
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjGPSCoordinates for LLRP parameter ImpinjGPSCoordinates.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
Class Definition CImpinjReaderTemperature for LLRP parameter ImpinjReaderTemperature.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjEnableRFDopplerFrequency for LLRP parameter ImpinjEnableRFDopplerFrequency.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjHubVersions for LLRP parameter ImpinjHubVersions.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjFixedFrequencyMode getFixedFrequencyMode(void)
Get accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjOpSpecRetryCount for LLRP parameter ImpinjOpSpecRetryCount.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjxArrayDirectionCapabilities * getImpinjxArrayDirectionCapabilities(void)
Get accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getIncRepLen(void)
Get accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
void setSupportsTSISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTSISpecs field.
void setTagPopulationStatus(EImpinjDirectionTagPopulationStatus value)
Set accessor functions for the LLRP TagPopulationStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
int countEPCData(void)
Count of the LLRP EPCData sub-parameter list.
void setFrequencyList(llrp_u32v_t value)
Set accessor functions for the LLRP FrequencyList field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjDirectionReporting for LLRP parameter ImpinjDirectionReporting.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u32_t getLoopCount(void)
Get accessor functions for the LLRP LoopCount field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
llrp_u1_t getSaveConfiguration(void)
Get accessor functions for the LLRP SaveConfiguration field.
Class Definition CImpinjGetBlockPermalockStatus for LLRP parameter ImpinjGetBlockPermalockStatus.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setDiagnosticReportLevel(EImpinjDirectionDiagnosticReportLevel value)
Set accessor functions for the LLRP DiagnosticReportLevel field.
void clearEPCData(void)
Clears the LLRP EPCData sub-parameter list.
std::list< CImpinjArrayVersion * >::iterator endImpinjArrayVersion(void)
Returns the last element of the ImpinjArrayVersion sub-parameter list.
Class Definition CImpinjTIDParity for LLRP parameter ImpinjTIDParity.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjArrayVersion(void)
Count of the LLRP ImpinjArrayVersion sub-parameter list.
llrp_utf8v_t getGGASentence(void)
Get accessor functions for the LLRP GGASentence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjGetBlockPermalockStatusResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u1_t getEnableSelectGapClose(void)
Get accessor functions for the LLRP EnableSelectGapClose field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u64_t getBeaconDurationSeconds(void)
Get accessor functions for the LLRP BeaconDurationSeconds field.
void setBeaconDurationSeconds(llrp_u64_t value)
Set accessor functions for the LLRP BeaconDurationSeconds field.
void setRetryCount(llrp_u16_t value)
Set accessor functions for the LLRP RetryCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setMinimumPowerLevel(llrp_u16_t value)
Set accessor functions for the LLRP MinimumPowerLevel field.
EImpinjQTPersistence getPersistence(void)
Get accessor functions for the LLRP Persistence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
void setFault(EImpinjHubFaultType value)
Set accessor functions for the LLRP Fault field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjSerializedTIDMode getSerializedTIDMode(void)
Get accessor functions for the LLRP SerializedTIDMode field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjLocationReporting * getImpinjLocationReporting(void)
Get accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
void setComputeWindowSeconds(llrp_u16_t value)
Set accessor functions for the LLRP ComputeWindowSeconds field.
void setGGASentence(llrp_utf8v_t value)
Set accessor functions for the LLRP GGASentence field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConfidenceData(llrp_u32v_t value)
Set accessor functions for the LLRP ConfidenceData field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjAntennaAttemptEvent for LLRP parameter ImpinjAntennaAttemptEvent.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
llrp_u1_t getEnableAntDwellTimeLimit(void)
Get accessor functions for the LLRP EnableAntDwellTimeLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjEnableGPSCoordinates * getImpinjEnableGPSCoordinates(void)
Get accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrientationDegrees(llrp_s16_t value)
Set accessor functions for the LLRP OrientationDegrees field.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setHubID(llrp_u16_t value)
Set accessor functions for the LLRP HubID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableOptimizedRead * getImpinjEnableOptimizedRead(void)
Get accessor functions for the LLRP ImpinjEnableOptimizedRead sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getFPGAVersion(void)
Get accessor functions for the LLRP FPGAVersion field.
CImpinjDirectionSectors * getImpinjDirectionSectors(void)
Get accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
EImpinjRegulatoryRegion getRegulatoryRegion(void)
Get accessor functions for the LLRP RegulatoryRegion field.
Class Definition CImpinjAdvancedGPOConfiguration for LLRP parameter ImpinjAdvancedGPOConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getGPIDebounceTimerMSec(void)
Get accessor functions for the LLRP GPIDebounceTimerMSec field.
void setIncRepLen(llrp_u1_t value)
Set accessor functions for the LLRP IncRepLen field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjSetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjLocationConfidence for LLRP parameter ImpinjLocationConfidence.
Class Definition CImpinjRFDopplerFrequency for LLRP parameter ImpinjRFDopplerFrequency.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUserTagPopulationLimit(llrp_u16_t value)
Set accessor functions for the LLRP UserTagPopulationLimit field.
llrp_utf8v_t getSoftwareVersion(void)
Get accessor functions for the LLRP SoftwareVersion field.
EImpinjLocationReportType getType(void)
Get accessor functions for the LLRP Type field.
void setResponse(llrp_u1v_t value)
Set accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16v_t getBlockMask(void)
Get accessor functions for the LLRP BlockMask field.
EImpinjBlockPermalockResultType getResult(void)
Get accessor functions for the LLRP Result field.
EImpinjAntennaPolarizationType getType(void)
Get accessor functions for the LLRP Type field.
Class Definition CImpinjDirectionUserTagPopulationLimit for LLRP parameter ImpinjDirectionUserTagPopu...
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getLocXCentimeters(void)
Get accessor functions for the LLRP LocXCentimeters field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaIDs(llrp_u16v_t value)
Set accessor functions for the LLRP AntennaIDs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Read * >::iterator endC1G2Read(void)
Returns the last element of the C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjSetQTConfigOpSpecResult for LLRP parameter ImpinjSetQTConfigOpSpecResult.
Class Definition CIMPINJ_ENABLE_EXTENSIONS for LLRP message IMPINJ_ENABLE_EXTENSIONS.
void setSystemTagPopulationLimitHighPerformance(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjGetQTConfig for LLRP parameter ImpinjGetQTConfig.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAccessSpecConfiguration for LLRP parameter ImpinjAccessSpecConfiguration.
Class Definition CImpinjFrequencyCapabilities for LLRP parameter ImpinjFrequencyCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnabledSectorIDs(llrp_u16v_t value)
Set accessor functions for the LLRP EnabledSectorIDs field.
void clearImpinjAntennaPolarizationCapability(void)
Clears the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
Class Definition CImpinjLinkMonitorConfiguration for LLRP parameter ImpinjLinkMonitorConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator endEPCData(void)
Returns the last element of the EPCData sub-parameter list.
CImpinjLocationConfidence * getImpinjLocationConfidence(void)
Get accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjMarginReadOpSpecResult for LLRP parameter ImpinjMarginReadOpSpecResult.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setManagementEnabled(EImpinjIntelligentAntennaMode value)
Set accessor functions for the LLRP ManagementEnabled field.
void setGPOPulseDurationMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPOPulseDurationMSec field.
Class Definition CImpinjxArrayDirectionCapabilities for LLRP parameter ImpinjxArrayDirectionCapabilit...
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaConfiguration for LLRP parameter ImpinjAntennaConfiguration.
EImpinjGPSCoordinatesMode getGPSCoordinatesMode(void)
Get accessor functions for the LLRP GPSCoordinatesMode field.
CImpinjAntennaEventConfiguration * getImpinjAntennaEventConfiguration(void)
Get accessor functions for the LLRP ImpinjAntennaEventConfiguration sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjHubConfiguration for LLRP parameter ImpinjHubConfiguration.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBitLength(llrp_u8_t value)
Set accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getSupportsTSISpecs(void)
Get accessor functions for the LLRP SupportsTSISpecs field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjReportBufferMode getReportBufferMode(void)
Get accessor functions for the LLRP ReportBufferMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getXAxis(void)
Get accessor functions for the LLRP XAxis field.
Class Definition CImpinjDirectionDiagnosticData for LLRP parameter ImpinjDirectionDiagnosticData.
void setLinkMonitorMode(EImpinjLinkMonitorMode value)
Set accessor functions for the LLRP LinkMonitorMode field.
Class Definition CImpinjEnableRFPhaseAngle for LLRP parameter ImpinjEnableRFPhaseAngle.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS_RESPONSE for LLRP message IMPINJ_SAVE_SETTINGS_RESPONSE.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_s16_t getOrientationDegrees(void)
Get accessor functions for the LLRP OrientationDegrees field.
Class Definition CImpinjExtendedTagInformation for LLRP parameter ImpinjExtendedTagInformation.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjDirectionDiagnosticReportLevel getDiagnosticReportLevel(void)
Get accessor functions for the LLRP DiagnosticReportLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFDopplerFrequencyMode getRFDopplerFrequencyMode(void)
Get accessor functions for the LLRP RFDopplerFrequencyMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
EImpinjInventorySearchType getInventorySearchMode(void)
Get accessor functions for the LLRP InventorySearchMode field.
Class Definition CImpinjGetBlockPermalockStatusOpSpecResult for LLRP parameter ImpinjGetBlockPermaloc...
CImpinjEnableSerializedTID * getImpinjEnableSerializedTID(void)
Get accessor functions for the LLRP ImpinjEnableSerializedTID sub-parameter.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
Class Definition CImpinjAntennaEventConfiguration for LLRP parameter ImpinjAntennaEventConfiguration...
CImpinjBLEVersion * getImpinjBLEVersion(void)
Get accessor functions for the LLRP ImpinjBLEVersion sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
void setSupportsLISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsLISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLocYCentimeters(void)
Get accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLastSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setRegulatoryRegion(EImpinjRegulatoryRegion value)
Set accessor functions for the LLRP RegulatoryRegion field.
void setTID(llrp_u16v_t value)
Set accessor functions for the LLRP TID field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
Class Definition CImpinjAccessSpecOrdering for LLRP parameter ImpinjAccessSpecOrdering.
Class Definition CImpinjAntennaCapabilities for LLRP parameter ImpinjAntennaCapabilities.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjSerializedTID for LLRP parameter ImpinjSerializedTID.
llrp_s32_t getFacilityXLocationCm(void)
Get accessor functions for the LLRP FacilityXLocationCm field.
void setMessage(llrp_u1v_t value)
Set accessor functions for the LLRP Message field.
Class Definition CImpinjGPIDebounceConfiguration for LLRP parameter ImpinjGPIDebounceConfiguration.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjOptimizedReadMode getOptimizedReadMode(void)
Get accessor functions for the LLRP OptimizedReadMode field.
llrp_u1_t getSupportsLISpecs(void)
Get accessor functions for the LLRP SupportsLISpecs field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableRFDopplerFrequency * getImpinjEnableRFDopplerFrequency(void)
Get accessor functions for the LLRP ImpinjEnableRFDopplerFrequency sub-parameter. ...
llrp_u8_t getEPCLength(void)
Get accessor functions for the LLRP EPCLength field.
llrp_s16_t getRSSI(void)
Get accessor functions for the LLRP RSSI field.
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
void setFirstSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP FirstSeenSectorID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjAccessSpecOrdering * getImpinjAccessSpecOrdering(void)
Get accessor functions for the LLRP ImpinjAccessSpecOrdering sub-parameter.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHeightCm(void)
Get accessor functions for the LLRP HeightCm field.
void setParityError(llrp_u1_t value)
Set accessor functions for the LLRP ParityError field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
void setOptimizedReadMode(EImpinjOptimizedReadMode value)
Set accessor functions for the LLRP OptimizedReadMode field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setType(EImpinjDirectionReportType value)
Set accessor functions for the LLRP Type field.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u32v_t getFrequencyList(void)
Get accessor functions for the LLRP FrequencyList field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator beginEPCData(void)
Returns the first element of the EPCData sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjC1G2DirectionConfig for LLRP parameter ImpinjC1G2DirectionConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void setTemperature(llrp_s16_t value)
Set accessor functions for the LLRP Temperature field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
CImpinjEnablePeakRSSI * getImpinjEnablePeakRSSI(void)
Get accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
CImpinjEnableTxPower * getImpinjEnableTxPower(void)
Get accessor functions for the LLRP ImpinjEnableTxPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
CImpinjAntennaEventHysteresis * getImpinjAntennaEventHysteresis(void)
Get accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLoopCount(llrp_u32_t value)
Set accessor functions for the LLRP LoopCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
Class Definition CImpinjReducedPowerFrequencyList for LLRP parameter ImpinjReducedPowerFrequencyList...
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjDISpec for LLRP parameter ImpinjDISpec.
void setBlockRange(llrp_u16_t value)
Set accessor functions for the LLRP BlockRange field.
void setReducedPowerMode(EImpinjReducedPowerMode value)
Set accessor functions for the LLRP ReducedPowerMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1v_t getResponse(void)
Get accessor functions for the LLRP Response field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u8_t getCSI(void)
Get accessor functions for the LLRP CSI field.
Class Definition CImpinjRMCSentence for LLRP parameter ImpinjRMCSentence.
EImpinjDirectionRFMode getRFMode(void)
Get accessor functions for the LLRP RFMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjAntennaPolarizationCapability(void)
Count of the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
Class Definition CImpinjEnableGPSCoordinates for LLRP parameter ImpinjEnableGPSCoordinates.
Class Definition CImpinjMarginRead for LLRP parameter ImpinjMarginRead.
void setPeakRSSIMode(EImpinjPeakRSSIMode value)
Set accessor functions for the LLRP PeakRSSIMode field.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjC1G2LocationConfig for LLRP parameter ImpinjC1G2LocationConfig.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEPCLength(llrp_u8_t value)
Set accessor functions for the LLRP EPCLength field.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEmptyFieldTimeout(llrp_u16_t value)
Set accessor functions for the LLRP EmptyFieldTimeout field.
void setAntennaEventConnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventConnected field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjLocationAlgorithmControl * getImpinjLocationAlgorithmControl(void)
Get accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.