Struct PortableBattery 

pub struct PortableBattery<'a> {
    pub handle: u16,
    pub location: &'a str,
    pub manufacturer: &'a str,
    pub manufacture_date: ManufactureDate<'a>,
    pub serial_number: SerialNumber<'a>,
    pub device_name: &'a str,
    pub device_chemistry: DeviceChemistry<'a>,
    pub design_capacity: DesignCapacity,
    pub design_voltage: u16,
    pub sbds_version_number: &'a str,
    pub maximum_error_in_battery_data: u8,
    pub oem_specific: Option<u32>,
}

Main struct for Portable Battery (Type 22)

Fields

handle: u16

Specifies the structure’s handle

location: &'a str

Location of the battery

manufacturer: &'a str

Company name that manufactured the battery

manufacture_date: ManufactureDate<'a>

serial_number: SerialNumber<'a>

device_name: &'a str

String that names the battery device

device_chemistry: DeviceChemistry<'a>

design_capacity: DesignCapacity

design_voltage: u16

Design voltage of the battery in mVolts.
If the value is unknown, the field contains 0.

sbds_version_number: &'a str

String that contains the Smart Battery Data Specification version number supported by this battery.
If the battery does not support the function, no string is supplied.

maximum_error_in_battery_data: u8

Maximum error (as a percentage in the range 0 to 100) in the Watt-hour data reported by the battery, indicating an upper bound on how much additional energy the battery might have above the energy it reports having.
If the value is unknown, the field contains FFh.

oem_specific: Option<u32>

Trait Implementations

impl<'a> Clone for PortableBattery<'a>

fn clone(&self) -> PortableBattery<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PortableBattery<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for PortableBattery<'a>

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<'a> PartialEq for PortableBattery<'a>

fn eq(&self, other: &PortableBattery<'a>) -> 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<'a> Copy for PortableBattery<'a>

impl<'a> Eq for PortableBattery<'a>

impl<'a> StructuralPartialEq for PortableBattery<'a>