e-h-bus: document fixes and inline hints.

luojia65 · luojia65 · commit d81f7b814296 · 2023-08-23T10:20:19.000+08:00
Signed-off-by: Zhouqi Jiang &lt;luojia@hust.edu.cn&gt;
diff --git a/embedded-hal-bus/src/i2c/critical_section.rs b/embedded-hal-bus/src/i2c/critical_section.rs
@@ -14,7 +14,8 @@ pub struct CriticalSectionDevice<'a, T> {
 }
 
 impl<'a, T> CriticalSectionDevice<'a, T> {
-    /// Create a new `CriticalSectionDevice`
+    /// Create a new `CriticalSectionDevice`.
+    #[inline]
     pub fn new(bus: &'a Mutex<RefCell<T>>) -> Self {
         Self { bus }
     }
@@ -31,20 +32,23 @@ impl<'a, T> I2c for CriticalSectionDevice<'a, T>
 where
     T: I2c,
 {
+    #[inline]
     fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
         critical_section::with(|cs| {
             let bus = &mut *self.bus.borrow_ref_mut(cs);
             bus.read(address, read)
         })
     }
 
+    #[inline]
     fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
         critical_section::with(|cs| {
             let bus = &mut *self.bus.borrow_ref_mut(cs);
             bus.write(address, write)
         })
     }
 
+    #[inline]
     fn write_read(
         &mut self,
         address: u8,
@@ -57,6 +61,7 @@ where
         })
     }
 
+    #[inline]
     fn transaction(
         &mut self,
         address: u8,
diff --git a/embedded-hal-bus/src/i2c/mutex.rs b/embedded-hal-bus/src/i2c/mutex.rs
@@ -12,7 +12,8 @@ pub struct MutexDevice<'a, T> {
 }
 
 impl<'a, T> MutexDevice<'a, T> {
-    /// Create a new `MutexDevice`
+    /// Create a new `MutexDevice`.
+    #[inline]
     pub fn new(bus: &'a Mutex<T>) -> Self {
         Self { bus }
     }
@@ -29,16 +30,19 @@ impl<'a, T> I2c for MutexDevice<'a, T>
 where
     T: I2c,
 {
+    #[inline]
     fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.lock().unwrap();
         bus.read(address, read)
     }
 
+    #[inline]
     fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.lock().unwrap();
         bus.write(address, write)
     }
 
+    #[inline]
     fn write_read(
         &mut self,
         address: u8,
@@ -49,6 +53,7 @@ where
         bus.write_read(address, write, read)
     }
 
+    #[inline]
     fn transaction(
         &mut self,
         address: u8,
diff --git a/embedded-hal-bus/src/i2c/refcell.rs b/embedded-hal-bus/src/i2c/refcell.rs
@@ -68,7 +68,8 @@ pub struct RefCellDevice<'a, T> {
 }
 
 impl<'a, T> RefCellDevice<'a, T> {
-    /// Create a new `RefCellDevice`
+    /// Create a new `RefCellDevice`.
+    #[inline]
     pub fn new(bus: &'a RefCell<T>) -> Self {
         Self { bus }
     }
@@ -85,16 +86,19 @@ impl<'a, T> I2c for RefCellDevice<'a, T>
 where
     T: I2c,
 {
+    #[inline]
     fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.borrow_mut();
         bus.read(address, read)
     }
 
+    #[inline]
     fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.borrow_mut();
         bus.write(address, write)
     }
 
+    #[inline]
     fn write_read(
         &mut self,
         address: u8,
@@ -105,6 +109,7 @@ where
         bus.write_read(address, write, read)
     }
 
+    #[inline]
     fn transaction(
         &mut self,
         address: u8,
diff --git a/embedded-hal-bus/src/spi/critical_section.rs b/embedded-hal-bus/src/spi/critical_section.rs
@@ -23,7 +23,8 @@ pub struct CriticalSectionDevice<'a, BUS, CS, D> {
 }
 
 impl<'a, BUS, CS, D> CriticalSectionDevice<'a, BUS, CS, D> {
-    /// Create a new ExclusiveDevice
+    /// Create a new ExclusiveDevice.
+    #[inline]
     pub fn new(bus: &'a Mutex<RefCell<BUS>>, cs: CS, delay: D) -> Self {
         Self { bus, cs, delay }
     }
@@ -36,6 +37,7 @@ impl<'a, BUS, CS> CriticalSectionDevice<'a, BUS, CS, super::NoDelay> {
     ///
     /// The returned device will panic if you try to execute a transaction
     /// that contains any operations of type `Operation::DelayUs`.
+    #[inline]
     pub fn new_no_delay(bus: &'a Mutex<RefCell<BUS>>, cs: CS) -> Self {
         Self {
             bus,
@@ -59,6 +61,7 @@ where
     CS: OutputPin,
     D: DelayUs,
 {
+    #[inline]
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         critical_section::with(|cs| {
             let bus = &mut *self.bus.borrow_ref_mut(cs);
diff --git a/embedded-hal-bus/src/spi/exclusive.rs b/embedded-hal-bus/src/spi/exclusive.rs
@@ -22,17 +22,20 @@ pub struct ExclusiveDevice<BUS, CS, D> {
 }
 
 impl<BUS, CS, D> ExclusiveDevice<BUS, CS, D> {
-    /// Create a new ExclusiveDevice
+    /// Create a new ExclusiveDevice.
+    #[inline]
     pub fn new(bus: BUS, cs: CS, delay: D) -> Self {
         Self { bus, cs, delay }
     }
 
     /// Returns a reference to the underlying bus object.
+    #[inline]
     pub fn bus(&self) -> &BUS {
         &self.bus
     }
 
     /// Returns a mutable reference to the underlying bus object.
+    #[inline]
     pub fn bus_mut(&mut self) -> &mut BUS {
         &mut self.bus
     }
@@ -45,6 +48,7 @@ impl<BUS, CS> ExclusiveDevice<BUS, CS, super::NoDelay> {
     ///
     /// The returned device will panic if you try to execute a transaction
     /// that contains any operations of type `Operation::DelayUs`.
+    #[inline]
     pub fn new_no_delay(bus: BUS, cs: CS) -> Self {
         Self {
             bus,
@@ -68,6 +72,7 @@ where
     CS: OutputPin,
     D: DelayUs,
 {
+    #[inline]
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         self.cs.set_low().map_err(DeviceError::Cs)?;
 
@@ -103,6 +108,7 @@ where
     CS: OutputPin,
     D: AsyncDelayUs,
 {
+    #[inline]
     async fn transaction(
         &mut self,
         operations: &mut [Operation<'_, Word>],
diff --git a/embedded-hal-bus/src/spi/mod.rs b/embedded-hal-bus/src/spi/mod.rs
@@ -21,9 +21,9 @@ use crate::defmt;
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 #[cfg_attr(feature = "defmt-03", derive(defmt::Format))]
 pub enum DeviceError<BUS, CS> {
-    /// An inner SPI bus operation failed
+    /// An inner SPI bus operation failed.
     Spi(BUS),
-    /// Asserting or deasserting CS failed
+    /// Asserting or deasserting CS failed.
     Cs(CS),
 }
 
@@ -32,6 +32,7 @@ where
     BUS: Error + Debug,
     CS: Debug,
 {
+    #[inline]
     fn kind(&self) -> ErrorKind {
         match self {
             Self::Spi(e) => e.kind(),
@@ -51,6 +52,7 @@ fn no_delay_panic() {
 }
 
 impl embedded_hal::delay::DelayUs for NoDelay {
+    #[inline]
     fn delay_us(&mut self, _us: u32) {
         no_delay_panic();
     }
@@ -59,11 +61,13 @@ impl embedded_hal::delay::DelayUs for NoDelay {
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 impl embedded_hal_async::delay::DelayUs for NoDelay {
+    #[inline]
     async fn delay_us(&mut self, _us: u32) {
         no_delay_panic();
     }
 
-    async fn delay_ms(&mut self, _us: u32) {
+    #[inline]
+    async fn delay_ms(&mut self, _ms: u32) {
         no_delay_panic();
     }
 }
diff --git a/embedded-hal-bus/src/spi/mutex.rs b/embedded-hal-bus/src/spi/mutex.rs
@@ -21,7 +21,8 @@ pub struct MutexDevice<'a, BUS, CS, D> {
 }
 
 impl<'a, BUS, CS, D> MutexDevice<'a, BUS, CS, D> {
-    /// Create a new ExclusiveDevice
+    /// Create a new MutexDevice.
+    #[inline]
     pub fn new(bus: &'a Mutex<BUS>, cs: CS, delay: D) -> Self {
         Self { bus, cs, delay }
     }
@@ -34,6 +35,7 @@ impl<'a, BUS, CS> MutexDevice<'a, BUS, CS, super::NoDelay> {
     ///
     /// The returned device will panic if you try to execute a transaction
     /// that contains any operations of type `Operation::DelayUs`.
+    #[inline]
     pub fn new_no_delay(bus: &'a Mutex<BUS>, cs: CS) -> Self {
         Self {
             bus,
@@ -57,6 +59,7 @@ where
     CS: OutputPin,
     D: DelayUs,
 {
+    #[inline]
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.lock().unwrap();
 
diff --git a/embedded-hal-bus/src/spi/refcell.rs b/embedded-hal-bus/src/spi/refcell.rs
@@ -20,7 +20,8 @@ pub struct RefCellDevice<'a, BUS, CS, D> {
 }
 
 impl<'a, BUS, CS, D> RefCellDevice<'a, BUS, CS, D> {
-    /// Create a new ExclusiveDevice
+    /// Create a new RefCellDevice.
+    #[inline]
     pub fn new(bus: &'a RefCell<BUS>, cs: CS, delay: D) -> Self {
         Self { bus, cs, delay }
     }
@@ -33,6 +34,7 @@ impl<'a, BUS, CS> RefCellDevice<'a, BUS, CS, super::NoDelay> {
     ///
     /// The returned device will panic if you try to execute a transaction
     /// that contains any operations of type `Operation::DelayUs`.
+    #[inline]
     pub fn new_no_delay(bus: &'a RefCell<BUS>, cs: CS) -> Self {
         Self {
             bus,
@@ -56,6 +58,7 @@ where
     CS: OutputPin,
     D: DelayUs,
 {
+    #[inline]
     fn transaction(&mut self, operations: &mut [Operation<'_, Word>]) -> Result<(), Self::Error> {
         let bus = &mut *self.bus.borrow_mut();
 

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ pub struct MutexDevice<'a, T> {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`impl<'a, T> MutexDevice<'a, T> {`
`15`		- /// Create a new `MutexDevice`
	`15`	+ /// Create a new `MutexDevice`.
	`16`	`+ #[inline]`
`16`	`17`	`pub fn new(bus: &'a Mutex<T>) -> Self {`
`17`	`18`	`Self { bus }`
`18`	`19`	`}`
`@@ -29,16 +30,19 @@ impl<'a, T> I2c for MutexDevice<'a, T>`
`29`	`30`	`where`
`30`	`31`	`T: I2c,`
`31`	`32`	`{`
	`33`	`+ #[inline]`
`32`	`34`	`fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {`
`33`	`35`	`let bus = &mut *self.bus.lock().unwrap();`
`34`	`36`	`bus.read(address, read)`
`35`	`37`	`}`
`36`	`38`
	`39`	`+ #[inline]`
`37`	`40`	`fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {`
`38`	`41`	`let bus = &mut *self.bus.lock().unwrap();`
`39`	`42`	`bus.write(address, write)`
`40`	`43`	`}`
`41`	`44`
	`45`	`+ #[inline]`
`42`	`46`	`fn write_read(`
`43`	`47`	`&mut self,`
`44`	`48`	`address: u8,`
`@@ -49,6 +53,7 @@ where`
`49`	`53`	`bus.write_read(address, write, read)`
`50`	`54`	`}`
`51`	`55`
	`56`	`+ #[inline]`
`52`	`57`	`fn transaction(`
`53`	`58`	`&mut self,`
`54`	`59`	`address: u8,`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,8 @@ pub struct RefCellDevice<'a, T> {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`impl<'a, T> RefCellDevice<'a, T> {`
`71`		- /// Create a new `RefCellDevice`
	`71`	+ /// Create a new `RefCellDevice`.
	`72`	`+ #[inline]`
`72`	`73`	`pub fn new(bus: &'a RefCell<T>) -> Self {`
`73`	`74`	`Self { bus }`
`74`	`75`	`}`
`@@ -85,16 +86,19 @@ impl<'a, T> I2c for RefCellDevice<'a, T>`
`85`	`86`	`where`
`86`	`87`	`T: I2c,`
`87`	`88`	`{`
	`89`	`+ #[inline]`
`88`	`90`	`fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {`
`89`	`91`	`let bus = &mut *self.bus.borrow_mut();`
`90`	`92`	`bus.read(address, read)`
`91`	`93`	`}`
`92`	`94`
	`95`	`+ #[inline]`
`93`	`96`	`fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {`
`94`	`97`	`let bus = &mut *self.bus.borrow_mut();`
`95`	`98`	`bus.write(address, write)`
`96`	`99`	`}`
`97`	`100`
	`101`	`+ #[inline]`
`98`	`102`	`fn write_read(`
`99`	`103`	`&mut self,`
`100`	`104`	`address: u8,`
`@@ -105,6 +109,7 @@ where`
`105`	`109`	`bus.write_read(address, write, read)`
`106`	`110`	`}`
`107`	`111`
	`112`	`+ #[inline]`
`108`	`113`	`fn transaction(`
`109`	`114`	`&mut self,`
`110`	`115`	`address: u8,`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ use crate::defmt;`
`21`	`21`	`#[derive(Copy, Clone, Eq, PartialEq, Debug)]`
`22`	`22`	`#[cfg_attr(feature = "defmt-03", derive(defmt::Format))]`
`23`	`23`	`pub enum DeviceError<BUS, CS> {`
`24`		`- /// An inner SPI bus operation failed`
	`24`	`+ /// An inner SPI bus operation failed.`
`25`	`25`	`Spi(BUS),`
`26`		`- /// Asserting or deasserting CS failed`
	`26`	`+ /// Asserting or deasserting CS failed.`
`27`	`27`	`Cs(CS),`
`28`	`28`	`}`
`29`	`29`
`@@ -32,6 +32,7 @@ where`
`32`	`32`	`BUS: Error + Debug,`
`33`	`33`	`CS: Debug,`
`34`	`34`	`{`
	`35`	`+ #[inline]`
`35`	`36`	`fn kind(&self) -> ErrorKind {`
`36`	`37`	`match self {`
`37`	`38`	`Self::Spi(e) => e.kind(),`
`@@ -51,6 +52,7 @@ fn no_delay_panic() {`
`51`	`52`	`}`
`52`	`53`
`53`	`54`	`impl embedded_hal::delay::DelayUs for NoDelay {`
	`55`	`+ #[inline]`
`54`	`56`	`fn delay_us(&mut self, _us: u32) {`
`55`	`57`	`no_delay_panic();`
`56`	`58`	`}`
`@@ -59,11 +61,13 @@ impl embedded_hal::delay::DelayUs for NoDelay {`
`59`	`61`	`#[cfg(feature = "async")]`
`60`	`62`	`#[cfg_attr(docsrs, doc(cfg(feature = "async")))]`
`61`	`63`	`impl embedded_hal_async::delay::DelayUs for NoDelay {`
	`64`	`+ #[inline]`
`62`	`65`	`async fn delay_us(&mut self, _us: u32) {`
`63`	`66`	`no_delay_panic();`
`64`	`67`	`}`
`65`	`68`
`66`		`- async fn delay_ms(&mut self, _us: u32) {`
	`69`	`+ #[inline]`
	`70`	`+ async fn delay_ms(&mut self, _ms: u32) {`
`67`	`71`	`no_delay_panic();`
`68`	`72`	`}`
`69`	`73`	`}`