Struct Bus 

pub struct Bus {
    pub name: String,
    pub host_controller: String,
    pub host_controller_vendor: Option<String>,
    pub host_controller_device: Option<String>,
    pub pci_vendor: Option<u16>,
    pub pci_device: Option<u16>,
    pub pci_revision: Option<u16>,
    pub usb_bus_number: Option<u8>,
    pub devices: Option<Vec<Device>>,
    /* private fields */
}

USB bus returned from system_profiler but now used for other platforms.

It is a merging of the PCI Host Controller information and root hub device data (if present). Essentially a root hub but not as a pseudo device but an explicit type - since the root hub is a bit confusing in that sense.

Fields

name: String

System internal bus name based on Root Hub device name

Normally something generic like ‘Root Hub’, ‘USB 3.0 Bus’

host_controller: String

System internal bus provider name

host_controller_vendor: Option<String>

Vendor name of PCI Host Controller from pci.ids

host_controller_device: Option<String>

Device name of PCI Host Controller from pci.ids

pci_vendor: Option<u16>

PCI vendor ID (VID)

pci_device: Option<u16>

PCI device ID (PID)

pci_revision: Option<u16>

PCI Revsision ID

usb_bus_number: Option<u8>

Number of bus on system

devices: Option<Vec<Device>>

Devices on the Bus. Since a device can have devices too, need to walk down all devices to get all devices on the bus

On Linux, the root hub is also included in this list

Implementations

impl Bus

Returns of Vec of devices in the Bus as a reference

pub fn len(&self) -> usize

Returns total number of devices in the bus

pub fn into_flattened_devices(&mut self)

Flattens the bus by copying each device into a new devices Vec

Unlike the flattened_devices which returns references that may still contain a Vec of Device, this function makes those None too since it is doing a hard copy.

Not very pretty or efficient, probably a better way…

pub fn flattened_devices(&self) -> Vec<&Device>

Returns a flattened Vec of references to all Devices on the bus

Note that whilst Vec of references is flat, the Devices still contain a devices Vec where the references point; recursive functions on the returned Vec will produce weird results

pub fn is_empty(&self) -> bool

Whether the bus has no Devices

pub fn has_empty_hubs(&self) -> bool

Whether the bus has just empty hubs

pub fn get_bus_number(&self) -> Option<u8>

usb_bus_number is not always present in system_profiler output so try to get from first device instead

pub fn path(&self) -> Option<PathBuf>

syspath style path to bus

pub fn interface(&self) -> Option<DevicePath>

sysfs style path to bus interface

pub fn remove_root_hub_device(&mut self)

Remove the root_hub if existing in bus

pub fn get_root_hub_device(&self) -> Option<&Device>

Gets the device that is the root_hub associated with this bus - Linux only but exists in case of using –from-json

pub fn get_root_hub_device_mut(&mut self) -> Option<&mut Device>

Gets a mutable device that is the root_hub associated with this bus - Linux only but exists in case of using –from-json

pub fn get_node(&self, port_path: &PortPath) -> Option<&Device>

Search for Device in branches of bus and return reference

pub fn get_node_mut(&mut self, port_path: &PortPath) -> Option<&mut Device>

Search for Device in branches of bus and return mutable if found

pub fn get_node_by_path<P: AsRef<Path>>(&self, port_path: P) -> Option<&Device>

Search for Device in branches of bus by Path and return reference

pub fn get_node_path_by_path_mut<P: AsRef<Path>>( &mut self, port_path: P, ) -> Option<&mut Device>

Search for Device in branches of bus by Path and return mutable reference

pub fn get_node_by_str(&self, path: &str) -> Option<&Device>

Search for reference to Device at port path as string

pub fn get_node_str_mut(&mut self, path: &str) -> Option<&mut Device>

Search for mutable reference to Device at port path as string

pub fn get_config( &self, port_path: &PortPath, config: u8, ) -> Option<&Configuration>

Get reference to Configuration at PortPath and config if present

pub fn get_config_mut( &mut self, port_path: &PortPath, config: u8, ) -> Option<&mut Configuration>

Get mutable reference to Configuration at PortPath and config if present

pub fn get_interface(&self, device_path: &DevicePath) -> Option<&Interface>

Get reference to Interface at DevicePath if config and interface are present

pub fn get_interface_mut( &mut self, device_path: &DevicePath, ) -> Option<&mut Interface>

Get mutable reference to Interface at DevicePath if config and interface are present

pub fn get_endpoint(&self, endpoint_path: &EndpointPath) -> Option<&Endpoint>

Get reference to Endpoint at EndpointPath if config and interface are present

pub fn get_endpoint_mut( &mut self, endpoint_path: &EndpointPath, ) -> Option<&mut Endpoint>

Get mutable reference to Endpoint at EndpointPath if config and interface are present

pub fn get_id(&self, id: &DeviceId) -> Option<&Device>

Search for ::nusb::DeviceId in branches of bus and return reference

pub fn get_id_mut(&mut self, id: &DeviceId) -> Option<&mut Device>

Search for ::nusb::DeviceId in branches of bus and returns a mutable reference if found

pub fn to_lsusb_string(&self) -> String

Generate a String from self like lsusb default list device

pub fn to_lsusb_tree_string(&self, verbosity: u8) -> Vec<String>

Generate a Vec of Strings from self in lsusb tree self in order of verbosity

Only Linux systems with a root_hub will contain accurate data, others are mainly for styling

pub fn is_hidden(&self) -> bool

Should the bus be hidden when printing

pub fn is_expanded(&self) -> bool

Should the bus be expanded when printing

pub fn toggle_expanded(&mut self)

Toggle the expanded state of the bus

pub fn set_all_expanded(&mut self, expanded: bool)

Set the expanded state of the bus and all devices

Trait Implementations

impl Block<BusBlocks, Bus> for BusBlocks

fn default_blocks(verbose: bool) -> Vec<Self>

List of default blocks to use for printing T with optional verbose for maximum verbosity

fn len(&self, d: &[&Bus]) -> usize

Returns the length of block value given device data - like block_length but actual device field length rather than fixed/heading

fn generate_padding(d: &[&Bus]) -> HashMap<Self, usize>

Creates a HashMap of B keys to usize of longest value for that key in the d Vec or heading if > this; values can then be padded to match this

fn colour(&self, s: &str, ct: &ColourTheme) -> ColoredString

Colour the block String

fn format_value( &self, bus: &Bus, pad: &HashMap<Self, usize>, settings: &PrintSettings, ) -> Option<String>

Formats the value associated with the block into a display String

fn heading(&self) -> &str

Creates the heading for the block value, for use with the heading flag

fn heading_padded(&self, pad: &HashMap<Self, usize>) -> String

Pads the heading with provided padding block HashMap

fn block_length(&self) -> BlockLength

Returns length type and usize contained, BlockLength::Variable will be heading usize without actual device data

fn is_icon(&self) -> bool

If the block is used for icons

const INSET: u8 = 0

The inset when printing non-tree as a list

fn example_blocks() -> Vec<Self>

where Self: Sized,

Example blocks for generated files

fn value_is_variable_length(&self) -> bool

Returns whether the value intended for the block is a variable length type (string descriptor)

fn format_base_u16(v: u16, settings: &PrintSettings) -> String

Formats u16 values like VID as base16 or base10 depending on decimal setting

fn format_base_u8(v: u8, settings: &PrintSettings) -> String

Formats u8 values like codes as base16 or base10 depending on decimal setting

fn format_vidpid( v: Option<u16>, p: Option<u16>, settings: &PrintSettings, ) -> String

Formats VID and PID values into a string like “vid:pid” with padding

fn all_blocks() -> &'static [B]

where Self: Sized,

Get static array of all blocks for this type

impl Clone for Bus

fn clone(&self) -> Bus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bus

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

Formats the value using the given formatter.

impl Default for Bus

fn default() -> Bus

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Bus

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Bus

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

Formats the value using the given formatter.

impl From<&BusInfo> for Bus

fn from(bus: &BusInfo) -> Self

Converts to this type from the input type.

impl From<u8> for Bus

A generic Bus from a u8 bus number - used if Bus profiling is not available

fn from(bus: u8) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a Bus

type Item = &'a Device

The type of the elements being iterated over.

type IntoIter = IntoIter<<&'a Bus as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<Self::Item>

Creates an iterator from a value.

impl Serialize for Bus

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Device> for Bus

type Error = Error

The type returned in the event of a conversion error.

fn try_from(device: Device) -> Result<Self>

Performs the conversion.