Enum ReportItem 

pub enum ReportItem {
    Input(Input),
    Output(Output),
    Feature(Feature),
    Collection(Collection),
    EndCollection(EndCollection),
    UsagePage(UsagePage),
    LogicalMinimum(LogicalMinimum),
    LogicalMaximum(LogicalMaximum),
    PhysicalMinimum(PhysicalMinimum),
    PhysicalMaximum(PhysicalMaximum),
    UnitExponent(UnitExponent),
    Unit(Unit),
    ReportSize(ReportSize),
    ReportId(ReportId),
    ReportCount(ReportCount),
    Push(Push),
    Pop(Pop),
    Usage(Usage),
    UsageMinimum(UsageMinimum),
    UsageMaximum(UsageMaximum),
    DesignatorIndex(DesignatorIndex),
    DesignatorMinimum(DesignatorMinimum),
    DesignatorMaximum(DesignatorMaximum),
    StringIndex(StringIndex),
    StringMinimum(StringMinimum),
    StringMaximum(StringMaximum),
    Delimiter(Delimiter),
    Reserved(Reserved),
}

Report items enumeration.

The HID Report descriptor is made up of items that provide information about the device.

All items contain a 1-byte prefix which denotes the basic type of the item. The HID class defines two basic formats for items:

• Short items: 1–5 bytes total length; used for the most commonly occurring items. A short item typically contains 1 or 0 bytes of optional data.
• Long items: 3–258 bytes in length; used for items that require larger data structures for parts.

NOTE: No long item tags are defined, these tags are reserved for future use.

The short item format packs the item size, type, and tag into the first byte. The first byte may be followed by 0, 1, 2, or 4 optional data bytes depending on the size of the data.

Bit -8	Bit 7-4	Bit 3-2	Bit 1-0
[data]	bTag	bType	bSize

bSize: Numeric expression specifying size of data:

bSize	size of data
0	0 bytes
1	1 byte
2	2 bytes
3	4 bytes

bType: Numeric expression identifying type of item where:

bType	type of item
0	Main
1	Global
2	Local
3	Reserved

bTag: Numeric expression specifying the function of the item.

Variants

Input(Input)

An Input item.

Output(Output)

An Output item.

Feature(Feature)

A Feature item.

Collection(Collection)

A Collection item.

EndCollection(EndCollection)

An EndCollection item.

UsagePage(UsagePage)

A UsagePage item.

LogicalMinimum(LogicalMinimum)

A LogicalMinimum item.

LogicalMaximum(LogicalMaximum)

A LogicalMaximum item.

PhysicalMinimum(PhysicalMinimum)

A PhysicalMinimum item.

PhysicalMaximum(PhysicalMaximum)

A PhysicalMaximum item.

UnitExponent(UnitExponent)

A UnitExponent item.

Unit(Unit)

A Unit item.

ReportSize(ReportSize)

A ReportSize item.

ReportId(ReportId)

A ReportId item.

ReportCount(ReportCount)

A ReportCount item.

Push(Push)

A Push item.

Pop(Pop)

A Pop item.

Usage(Usage)

A Usage item.

UsageMinimum(UsageMinimum)

A UsageMinimum item.

UsageMaximum(UsageMaximum)

A UsageMaximum item.

DesignatorIndex(DesignatorIndex)

A DesignatorIndex item.

DesignatorMinimum(DesignatorMinimum)

A DesignatorMinimum item.

DesignatorMaximum(DesignatorMaximum)

A DesignatorMaximum item.

StringIndex(StringIndex)

A StringIndex item.

StringMinimum(StringMinimum)

A StringMinimum item.

StringMaximum(StringMaximum)

A StringMaximum item.

Delimiter(Delimiter)

A Delimiter item.

Reserved(Reserved)

A Reserved item.

Implementations

impl ReportItem

pub fn new(raw: &[u8]) -> Result<Self, HidError>

Create a new item from raw byte stream.

Items that cannot be recognized will be treated as Reserved. If you want to fail on unknown items, use new_strict() instead.

Example

use hid_report::ReportItem;

let raw = [0x26, 0x3c, 0x02];
let item = ReportItem::new(&raw).unwrap();
assert!(matches!(item, ReportItem::LogicalMaximum(_)));
assert_eq!(item.to_string(), "Logical Maximum (572)");

pub fn new_strict(raw: &[u8]) -> Result<Self, HidError>

Create a new item from raw byte stream in strict mode.

Items that cannot be recognized will be treated as HidError::ReservedItem.

pub unsafe fn new_unchecked(raw: &[u8]) -> Self

Create a new item from raw byte stream, without checking data length.

Items that cannot be recognized will be treated as Reserved. If you want to fail on unknown items, use new_strict_unchecked() instead.

Safety

You should ensure that the raw data is a valid HID report item.

pub unsafe fn new_strict_unchecked(raw: &[u8]) -> Result<Self, HidError>

Create a new item from raw byte stream in strict mode, without checking data length.

Items that cannot be recognized will be treated as HidError::ReservedItem. Also, this is the only error that may be reported.

Safety

You should ensure that the raw data is a valid HID report item.

pub fn prefix(&self) -> u8

Get prefix part of the item. Equivalent to item.as_ref()[0].

pub fn data(&self) -> &[u8]

Get data part of the item. Equivalent to &item.as_ref()[1..].

Trait Implementations

impl AsRef<[u8]> for ReportItem

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ReportItem

fn clone(&self) -> ReportItem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReportItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ReportItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ReportItem

fn eq(&self, other: &ReportItem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ReportItem

impl StructuralPartialEq for ReportItem