Add blanket impls for references

Author: GrantM11235

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `IoPin` trait for pins that can change between being inputs or outputs
   dynamically.
 - Added `Debug` to all spi mode types.
+- Added blanket impls for references.
 
 ### Changed
 - Swap PWM channel arguments to references

src/adc.rs

@@ -51,6 +51,14 @@ pub mod nb {
         fn channel(&self) -> Self::ID;
     }
 
+    impl<T: Channel<ADC>, ADC> Channel<ADC> for &T {
+        type ID = T::ID;
+
+        fn channel(&self) -> Self::ID {
+            (*self).channel()
+        }
+    }
+
     /// ADCs that sample on single channels per request, and do so at the time of the request.
     ///
     /// This trait is the interface to an ADC that is configured to read a specific channel at the time
@@ -92,4 +100,15 @@ pub mod nb {
         /// whatever channel underlies the pin.
         fn read(&mut self, pin: &mut Pin) -> nb::Result<Word, Self::Error>;
     }
+
+    impl<T, ADC, Word, Pin: Channel<ADC>> OneShot<ADC, Word, Pin> for &mut T
+    where
+        T: OneShot<ADC, Word, Pin>,
+    {
+        type Error = T::Error;
+
+        fn read(&mut self, pin: &mut Pin) -> nb::Result<Word, Self::Error> {
+            (*self).read(pin)
+        }
+    }
 }

src/capture.rs

@@ -94,4 +94,37 @@ pub mod nb {
         where
             R: Into<Self::Time>;
     }
+
+    impl<T: Capture> Capture for &mut T {
+        type Error = T::Error;
+
+        type Channel = T::Channel;
+
+        type Time = T::Time;
+
+        type Capture = T::Capture;
+
+        fn capture(&mut self, channel: Self::Channel) -> nb::Result<Self::Capture, Self::Error> {
+            (*self).capture(channel)
+        }
+
+        fn disable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {
+            (*self).disable(channel)
+        }
+
+        fn enable(&mut self, channel: Self::Channel) -> Result<(), Self::Error> {
+            (*self).enable(channel)
+        }
+
+        fn get_resolution(&self) -> Result<Self::Time, Self::Error> {
+            (**self).get_resolution()
+        }
+
+        fn set_resolution<R>(&mut self, resolution: R) -> Result<(), Self::Error>
+        where
+            R: Into<Self::Time>,
+        {
+            (*self).set_resolution(resolution)
+        }
+    }
 }

src/delay.rs

@@ -21,6 +21,14 @@ pub mod blocking {
         fn delay_ms(&mut self, ms: UXX) -> Result<(), Self::Error>;
     }
 
+    impl<UXX, T: DelayMs<UXX>> DelayMs<UXX> for &mut T {
+        type Error = T::Error;
+
+        fn delay_ms(&mut self, ms: UXX) -> Result<(), Self::Error> {
+            (*self).delay_ms(ms)
+        }
+    }
+
     /// Microsecond delay
     ///
     /// `UXX` denotes the range type of the delay time. `UXX` can be `u8`, `u16`, etc. A single type can
@@ -32,4 +40,12 @@ pub mod blocking {
         /// Pauses execution for `us` microseconds
         fn delay_us(&mut self, us: UXX) -> Result<(), Self::Error>;
     }
+
+    impl<UXX, T: DelayUs<UXX>> DelayUs<UXX> for &mut T {
+        type Error = T::Error;
+
+        fn delay_us(&mut self, us: UXX) -> Result<(), Self::Error> {
+            (*self).delay_us(us)
+        }
+    }
 }

src/digital.rs

@@ -77,6 +77,22 @@ pub mod blocking {
         }
     }
 
+    impl<T: OutputPin> OutputPin for &mut T {
+        type Error = T::Error;
+
+        fn set_low(&mut self) -> Result<(), Self::Error> {
+            (*self).set_low()
+        }
+
+        fn set_high(&mut self) -> Result<(), Self::Error> {
+            (*self).set_high()
+        }
+
+        fn set_state(&mut self, state: PinState) -> Result<(), Self::Error> {
+            (*self).set_state(state)
+        }
+    }
+
     /// Push-pull output pin that can read its output state
     pub trait StatefulOutputPin: OutputPin {
         /// Is the pin in drive high mode?
@@ -90,6 +106,16 @@ pub mod blocking {
         fn is_set_low(&self) -> Result<bool, Self::Error>;
     }
 
+    impl<T: StatefulOutputPin> StatefulOutputPin for &mut T {
+        fn is_set_high(&self) -> Result<bool, Self::Error> {
+            (**self).is_set_high()
+        }
+
+        fn is_set_low(&self) -> Result<bool, Self::Error> {
+            (**self).is_set_low()
+        }
+    }
+
     /// Output pin that can be toggled
     ///
     /// See [toggleable](toggleable) to use a software implementation if
@@ -104,6 +130,14 @@ pub mod blocking {
         fn toggle(&mut self) -> Result<(), Self::Error>;
     }
 
+    impl<T: ToggleableOutputPin> ToggleableOutputPin for &mut T {
+        type Error = T::Error;
+
+        fn toggle(&mut self) -> Result<(), Self::Error> {
+            (*self).toggle()
+        }
+    }
+
     /// Single digital input pin
     pub trait InputPin {
         /// Error type
@@ -116,6 +150,18 @@ pub mod blocking {
         fn is_low(&self) -> Result<bool, Self::Error>;
     }
 
+    impl<T: InputPin> InputPin for &T {
+        type Error = T::Error;
+
+        fn is_high(&self) -> Result<bool, Self::Error> {
+            (*self).is_high()
+        }
+
+        fn is_low(&self) -> Result<bool, Self::Error> {
+            (*self).is_low()
+        }
+    }
+
     /// Single pin that can switch from input to output mode, and vice-versa.
     ///
     /// Example use (assumes the `Error` type is the same for the `IoPin`,

src/i2c.rs

@@ -147,6 +147,14 @@ pub mod blocking {
         fn read(&mut self, address: A, buffer: &mut [u8]) -> Result<(), Self::Error>;
     }
 
+    impl<A: AddressMode, T: Read<A>> Read<A> for &mut T {
+        type Error = T::Error;
+
+        fn read(&mut self, address: A, buffer: &mut [u8]) -> Result<(), Self::Error> {
+            (*self).read(address, buffer)
+        }
+    }
+
     /// Blocking write
     pub trait Write<A: AddressMode = SevenBitAddress> {
         /// Error type
@@ -171,6 +179,14 @@ pub mod blocking {
         fn write(&mut self, address: A, bytes: &[u8]) -> Result<(), Self::Error>;
     }
 
+    impl<A: AddressMode, T: Write<A>> Write<A> for &mut T {
+        type Error = T::Error;
+
+        fn write(&mut self, address: A, bytes: &[u8]) -> Result<(), Self::Error> {
+            (*self).write(address, bytes)
+        }
+    }
+
     /// Blocking write (iterator version)
     pub trait WriteIter<A: AddressMode = SevenBitAddress> {
         /// Error type
@@ -186,6 +202,17 @@ pub mod blocking {
             B: IntoIterator<Item = u8>;
     }
 
+    impl<A: AddressMode, T: WriteIter<A>> WriteIter<A> for &mut T {
+        type Error = T::Error;
+
+        fn write_iter<B>(&mut self, address: A, bytes: B) -> Result<(), Self::Error>
+        where
+            B: IntoIterator<Item = u8>,
+        {
+            (*self).write_iter(address, bytes)
+        }
+    }
+
     /// Blocking write + read
     pub trait WriteRead<A: AddressMode = SevenBitAddress> {
         /// Error type
@@ -221,6 +248,19 @@ pub mod blocking {
         ) -> Result<(), Self::Error>;
     }
 
+    impl<A: AddressMode, T: WriteRead<A>> WriteRead<A> for &mut T {
+        type Error = T::Error;
+
+        fn write_read(
+            &mut self,
+            address: A,
+            bytes: &[u8],
+            buffer: &mut [u8],
+        ) -> Result<(), Self::Error> {
+            (*self).write_read(address, bytes, buffer)
+        }
+    }
+
     /// Blocking write (iterator version) + read
     pub trait WriteIterRead<A: AddressMode = SevenBitAddress> {
         /// Error type
@@ -242,6 +282,22 @@ pub mod blocking {
             B: IntoIterator<Item = u8>;
     }
 
+    impl<A: AddressMode, T: WriteIterRead<A>> WriteIterRead<A> for &mut T {
+        type Error = T::Error;
+
+        fn write_iter_read<B>(
+            &mut self,
+            address: A,
+            bytes: B,
+            buffer: &mut [u8],
+        ) -> Result<(), Self::Error>
+        where
+            B: IntoIterator<Item = u8>,
+        {
+            (*self).write_iter_read(address, bytes, buffer)
+        }
+    }
+
     /// Transactional I2C operation.
     ///
     /// Several operations can be combined as part of a transaction.
@@ -280,6 +336,18 @@ pub mod blocking {
         ) -> Result<(), Self::Error>;
     }
 
+    impl<A: AddressMode, T: Transactional<A>> Transactional<A> for &mut T {
+        type Error = T::Error;
+
+        fn exec<'a>(
+            &mut self,
+            address: A,
+            operations: &mut [Operation<'a>],
+        ) -> Result<(), Self::Error> {
+            (*self).exec(address, operations)
+        }
+    }
+
     /// Transactional I2C interface (iterator version).
     ///
     /// This allows combining operation within an I2C transaction.
@@ -304,4 +372,15 @@ pub mod blocking {
         where
             O: IntoIterator<Item = Operation<'a>>;
     }
+
+    impl<A: AddressMode, T: TransactionalIter<A>> TransactionalIter<A> for &mut T {
+        type Error = T::Error;
+
+        fn exec_iter<'a, O>(&mut self, address: A, operations: O) -> Result<(), Self::Error>
+        where
+            O: IntoIterator<Item = Operation<'a>>,
+        {
+            (*self).exec_iter(address, operations)
+        }
+    }
 }

src/pwm.rs

@@ -102,6 +102,51 @@ pub mod blocking {
             P: Into<Self::Time>;
     }
 
+    impl<T: Pwm> Pwm for &mut T {
+        type Error = T::Error;
+
+        type Channel = T::Channel;
+
+        type Time = T::Time;
+
+        type Duty = T::Duty;
+
+        fn disable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {
+            (*self).disable(channel)
+        }
+
+        fn enable(&mut self, channel: &Self::Channel) -> Result<(), Self::Error> {
+            (*self).enable(channel)
+        }
+
+        fn get_period(&self) -> Result<Self::Time, Self::Error> {
+            (**self).get_period()
+        }
+
+        fn get_duty(&self, channel: &Self::Channel) -> Result<Self::Duty, Self::Error> {
+            (**self).get_duty(channel)
+        }
+
+        fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {
+            (**self).get_max_duty()
+        }
+
+        fn set_duty(
+            &mut self,
+            channel: &Self::Channel,
+            duty: Self::Duty,
+        ) -> Result<(), Self::Error> {
+            (*self).set_duty(channel, duty)
+        }
+
+        fn set_period<P>(&mut self, period: P) -> Result<(), Self::Error>
+        where
+            P: Into<Self::Time>,
+        {
+            (*self).set_period(period)
+        }
+    }
+
     /// A single PWM channel / pin
     ///
     /// See `Pwm` for details
@@ -133,4 +178,30 @@ pub mod blocking {
         /// Sets a new duty cycle
         fn set_duty(&mut self, duty: Self::Duty) -> Result<(), Self::Error>;
     }
+
+    impl<T: PwmPin> PwmPin for &mut T {
+        type Error = T::Error;
+
+        type Duty = T::Duty;
+
+        fn disable(&mut self) -> Result<(), Self::Error> {
+            (*self).disable()
+        }
+
+        fn enable(&mut self) -> Result<(), Self::Error> {
+            (*self).enable()
+        }
+
+        fn get_duty(&self) -> Result<Self::Duty, Self::Error> {
+            (**self).get_duty()
+        }
+
+        fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {
+            (**self).get_max_duty()
+        }
+
+        fn set_duty(&mut self, duty: Self::Duty) -> Result<(), Self::Error> {
+            (*self).set_duty(duty)
+        }
+    }
 }