Enum DeviceKind 

pub enum DeviceKind {
    Mouse,
    Keyboard,
    Numpad,
    Presenter,
    Remote,
    Trackball,
    Touchpad,
    Tablet,
    Gamepad,
    Joystick,
    Headset,
    Unknown,
}

What a paired peripheral is. Mirrors hidpp::receiver::bolt::BoltDeviceKind but is owned by us so consumers don’t depend on hidpp.

Several upstream “device type” vocabularies feed this one enum, and they do not agree on numbers: the Bolt pairing register uses Unknown=0, Keyboard=1, Mouse=2, …, while the HID++ 0x0005 feature uses Keyboard=0, …, Mouse=3, … (no Unknown at all). The asset registry adds a third, free-form string type ("mouse", case-inconsistently "MOUSE"). They are converted to this enum at their respective boundaries — never by reinterpreting one source’s raw byte with another’s table — so the numeric mismatch can’t leak past those mappers.

Variants

Mouse

Keyboard

Numpad

Presenter

Remote

Trackball

Touchpad

Tablet

Gamepad

Joystick

Headset

Unknown

Implementations

impl DeviceKind

pub fn from_registry_type(raw: &str) -> Self

Parse the OpenLogi asset registry’s type string into a DeviceKind.

The registry field is free-form and case-inconsistent (both "mouse" and "MOUSE" ship), so we case-fold before matching. Values we don’t model map to DeviceKind::Unknown, which callers treat as “no asset opinion” and fall back to the HID++ classification.

Trait Implementations

impl Clone for DeviceKind

fn clone(&self) -> DeviceKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DeviceKind

impl Debug for DeviceKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeviceKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DeviceKind

impl Hash for DeviceKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DeviceKind

fn eq(&self, other: &DeviceKind) -> 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 Serialize for DeviceKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DeviceKind