Fixed v1/v2 compatibility.

v1 -> v2 promotion now implicit, v2 -> v1 regression must be explicit with `.into()`

Author: ryankurte

Cargo.toml

@@ -26,8 +26,6 @@ futures = "0.1.17"
 
 [features]
 unproven = ["nb/unstable"]
-v1-compat = []
-v2-compat = []
 
 [package.metadata.docs.rs]
 features = ["unproven"]

src/digital/mod.rs

@@ -1,6 +1,7 @@
 //! Digital I/O
 //!
 //! 
+//!
 
 // Depreciated / infallible traits
 #[deprecated(since = "0.2.2", note = "Deprecated because the methods cannot return errors. \
@@ -12,12 +13,12 @@ pub mod v2;
 
 // Compatibility shims, only one can be active at a time to avoid recursive errors
 
-// v2 -> v1 compatibility shims
-#[cfg(feature = "v1-compat")]
+// v2 -> v1 compatibility wrappers
+// These require explicit casts from v2 -> v1
 pub mod v1_compat;
 
 // v1 -> v2 compatibility shims
-#[cfg(feature = "v2-compat")]
+// These are implicit over v1 implementations
 pub mod v2_compat;
 
 // Re-export old traits so this isn't a breaking change

src/digital/v1_compat.rs

@@ -1,64 +1,98 @@
-//! v1 compatibility shims
+//! v1 compatibility wrapper
 //! this module adds reverse support for v2 digital traits
-//! only on of v1_compat or v2_compat may be included at a given time
+//! v2 traits must be explicitly cast to the v1 version using `.into()`.
 
 #[allow(deprecated)]
 use super::v1;
 use super::v2;
 
+/// Wrapper to allow v2 fallible OutputPin traits to be converted to v1 traits
+pub struct OldOutputPin<T> {
+    pin: T,
+}
+
+impl <T, ERR> From<T> for OldOutputPin<T>
+where
+    T: v2::OutputPin<Error=ERR>,
+    ERR: core::fmt::Debug,
+{
+    fn from(pin: T) -> Self {
+        OldOutputPin{pin}
+    }
+}
+
 /// Implementation of v1 OutputPin trait for v2 fallible output pins
 #[allow(deprecated)]
-impl <T, ERR> v1::OutputPin for T
+impl <T, ERR> v1::OutputPin for OldOutputPin<T>
 where
     T: v2::OutputPin<Error=ERR>,
     ERR: core::fmt::Debug,
 {
     fn set_low(&mut self) {
-        self.set_low().unwrap()
+        self.pin.set_low().unwrap()
     }
 
     fn set_high(&mut self) {
-        self.set_high().unwrap()
+        self.pin.set_high().unwrap()
     }
 }
 
 /// Implementation of v1 StatefulOutputPin trait for v2 fallible pins
 #[cfg(feature = "unproven")]
 #[allow(deprecated)]
-impl <T, ERR> v1::StatefulOutputPin for T 
+impl <T, ERR> v1::StatefulOutputPin for OldOutputPin<T> 
 where
     T: v2::StatefulOutputPin<Error=ERR>,
     ERR: core::fmt::Debug,
 {
     fn is_set_low(&self) -> bool {
-        self.is_set_low().unwrap()
+        self.pin.is_set_low().unwrap()
     }
 
     fn is_set_high(&self) -> bool {
-        self.is_set_high().unwrap()
+        self.pin.is_set_high().unwrap()
+    }
+}
+
+/// Wrapper to allow v2 fallible InputPin traits to be converted to v1 traits
+#[cfg(feature = "unproven")]
+pub struct OldInputPin<T> {
+    pin: T,
+}
+
+#[cfg(feature = "unproven")]
+impl <T, ERR> From<T> for OldInputPin<T>
+where
+    T: v2::InputPin<Error=ERR>,
+    ERR: core::fmt::Debug,
+{
+    fn from(pin: T) -> Self {
+        OldInputPin{pin}
     }
 }
 
 /// Implementation of v0.2 InputPin trait for v0.3 fallible pins
 #[cfg(feature = "unproven")]
 #[allow(deprecated)]
-impl <T, ERR> v1::InputPin for T 
+impl <T, ERR> v1::InputPin for OldInputPin<T>
 where
     T: v2::InputPin<Error=ERR>,
     ERR: core::fmt::Debug,
 {
     fn is_low(&self) -> bool {
-        self.is_low().unwrap()
+        self.pin.is_low().unwrap()
     }
 
     fn is_high(&self) -> bool {
-        self.is_high().unwrap()
+        self.pin.is_high().unwrap()
     }
 }
 
 #[cfg(test)]
 #[allow(deprecated)]
 mod tests {
+    use super::*;
+
     #[allow(deprecated)]
     use crate::digital::v1;
     use crate::digital::v2;
@@ -87,16 +121,57 @@ mod tests {
 
     #[allow(deprecated)]
     impl <T>OldOutputPinConsumer<T> 
-    where T: v1::OutputPin {
+    where T: v1::OutputPin 
+    {
         pub fn new(pin: T) -> OldOutputPinConsumer<T> {
             OldOutputPinConsumer{ _pin: pin }
         }
     }
 
     #[test]
-    fn new_old() {
+    fn v1_v2_output_explicit() {
         let i = NewOutputPinImpl{state: false};
-        let _c = OldOutputPinConsumer::new(i);
+        let _c: OldOutputPinConsumer<OldOutputPin<_>> = OldOutputPinConsumer::new(i.into());
+    }
+
+    #[cfg(feature = "unproven")]
+    struct NewInputPinImpl {
+        state: bool,
+    }
+
+    #[cfg(feature = "unproven")]
+    impl v2::InputPin for NewInputPinImpl {
+        type Error = ();
+
+        fn is_low(&self) -> Result<bool, Self::Error> {
+            Ok(!self.state)
+        }
+        fn is_high(&self) -> Result<bool, Self::Error>{
+            Ok(self.state)
+        }
+    }
+
+    #[cfg(feature = "unproven")]
+    #[allow(deprecated)]
+    struct OldInputPinConsumer<T: v1::InputPin> {
+        _pin: T,
+    }
+
+    #[cfg(feature = "unproven")]
+    #[allow(deprecated)]
+    impl <T>OldInputPinConsumer<T> 
+    where T: v1::InputPin 
+    {
+        pub fn new(pin: T) -> OldInputPinConsumer<T> {
+            OldInputPinConsumer{ _pin: pin }
+        }
+    }
+
+    #[cfg(feature = "unproven")]
+    #[test]
+    fn v1_v2_input_explicit() {
+        let i = NewInputPinImpl{state: false};
+        let _c: OldInputPinConsumer<OldInputPin<_>> = OldInputPinConsumer::new(i.into());
     }
 
 }

src/digital/v2_compat.rs

@@ -93,7 +93,44 @@ mod tests {
     }
 
     #[test]
-    fn old_new() {
+    fn v2_v1_output_implicit() {
+        let i = OldOutputPinImpl{state: false};
+        let _c = NewOutputPinConsumer::new(i);
+    }
+
+    #[cfg(feature = "unproven")]
+    #[allow(deprecated)]
+    struct OldInputPinImpl { 
+        state: bool
+    }
+
+    #[cfg(feature = "unproven")]
+    #[allow(deprecated)]
+    impl v1::InputPin for OldInputPinImpl {
+        fn is_low(&self) -> bool {
+            !self.state
+        }
+        fn is_high(&self) -> bool {
+            self.state
+        }
+    }
+
+    #[cfg(feature = "unproven")]
+    struct NewInputPinConsumer<T: v2::InputPin> {
+        _pin: T,
+    }
+
+    #[cfg(feature = "unproven")]
+    impl <T>NewInputPinConsumer<T> 
+    where T: v2::InputPin {
+        pub fn new(pin: T) -> NewInputPinConsumer<T> {
+            NewInputPinConsumer{ _pin: pin }
+        }
+    }
+
+    #[cfg(feature = "unproven")]
+    #[test]
+    fn v2_v1_input_implicit() {
         let i = OldOutputPinImpl{state: false};
         let _c = NewOutputPinConsumer::new(i);
     }