Rename serial trait methods try_*

timokroeger · Mar 12, 2020 · da83c02 · da83c02
1 parent b5ad852
commit da83c02
Show file tree

Hide file tree

Showing 4 changed files with 23 additions and 23 deletions.
diff --git a/src/blocking/serial.rs b/src/blocking/serial.rs
@@ -40,14 +40,14 @@ pub mod write {
 
         fn try_bwrite_all(&mut self, buffer: &[Word]) -> Result<(), Self::Error> {
             for word in buffer {
-                block!(self.write(word.clone()))?;
+                block!(self.try_write(word.clone()))?;
             }
 
             Ok(())
         }
 
         fn try_bflush(&mut self) -> Result<(), Self::Error> {
-            block!(self.flush())?;
+            block!(self.try_flush())?;
             Ok(())
         }
     }

diff --git a/src/fmt.rs b/src/fmt.rs
@@ -11,7 +11,7 @@ where
         let _ = s
             .as_bytes()
             .into_iter()
-            .map(|c| block!(self.write(Word::from(*c))))
+            .map(|c| block!(self.try_write(Word::from(*c))))
             .last();
         Ok(())
     }

diff --git a/src/lib.rs b/src/lib.rs
@@ -75,10 +75,10 @@
 //!     type Error;
 //!
 //!     /// Reads a single byte
-//!     fn read(&mut self) -> nb::Result<u8, Self::Error>;
+//!     fn try_read(&mut self) -> nb::Result<u8, Self::Error>;
 //!
 //!     /// Writes a single byte
-//!     fn write(&mut self, byte: u8) -> nb::Result<(), Self::Error>;
+//!     fn try_write(&mut self, byte: u8) -> nb::Result<(), Self::Error>;
 //! }
 //! ```
 //!
@@ -150,7 +150,7 @@
 //! impl hal::serial::Read<u8> for Serial<USART1> {
 //!     type Error = Error;
 //!
-//!     fn read(&mut self) -> nb::Result<u8, Error> {
+//!     fn try_read(&mut self) -> nb::Result<u8, Error> {
 //!         // read the status register
 //!         let isr = self.usart.isr.read();
 //!
@@ -172,13 +172,13 @@
 //! impl hal::serial::Write<u8> for Serial<USART1> {
 //!     type Error = Error;
 //!
-//!     fn write(&mut self, byte: u8) -> nb::Result<(), Error> {
-//!         // Similar to the `read` implementation
+//!     fn try_write(&mut self, byte: u8) -> nb::Result<(), Error> {
+//!         // Similar to the `try_read` implementation
 //!         # Ok(())
 //!     }
 //!
-//!     fn flush(&mut self) -> nb::Result<(), Error> {
-//!         // Similar to the `read` implementation
+//!     fn try_flush(&mut self) -> nb::Result<(), Error> {
+//!         // Similar to the `try_read` implementation
 //!         # Ok(())
 //!     }
 //! }
@@ -281,7 +281,7 @@
 //! {
 //!     let mut serial = Some(serial);
 //!     future::poll_fn(move || {
-//!         let byte = try_nb!(serial.as_mut().unwrap().read());
+//!         let byte = try_nb!(serial.as_mut().unwrap().try_read());
 //!
 //!         Ok(Async::Ready((serial.take().unwrap(), byte)))
 //!     })
@@ -296,7 +296,7 @@
 //! {
 //!     let mut serial = Some(serial);
 //!     future::poll_fn(move || {
-//!         try_nb!(serial.as_mut().unwrap().write(byte));
+//!         try_nb!(serial.as_mut().unwrap().try_write(byte));
 //!
 //!         Ok(Async::Ready(serial.take().unwrap()))
 //!     })
@@ -361,12 +361,12 @@
 //! #     pub struct Serial1;
 //! #     impl ::hal::serial::Read<u8> for Serial1 {
 //! #         type Error = Infallible;
-//! #         fn read(&mut self) -> ::nb::Result<u8, Infallible> { Err(::nb::Error::WouldBlock) }
+//! #         fn try_read(&mut self) -> ::nb::Result<u8, Infallible> { Err(::nb::Error::WouldBlock) }
 //! #     }
 //! #     impl ::hal::serial::Write<u8> for Serial1 {
 //! #         type Error = Infallible;
-//! #         fn flush(&mut self) -> ::nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
-//! #         fn write(&mut self, _: u8) -> ::nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
+//! #         fn try_flush(&mut self) -> ::nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
+//! #         fn try_write(&mut self, _: u8) -> ::nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
 //! #     }
 //! #
 //! #     pub struct Led;
@@ -492,7 +492,7 @@
 //!     S: hal::serial::Write<u8>
 //! {
 //!     for &byte in buffer {
-//!         block!(serial.write(byte))?;
+//!         block!(serial.try_write(byte))?;
 //!     }
 //!
 //!     Ok(())
@@ -528,7 +528,7 @@
 //!     timer.try_start(timeout).map_err(Error::TimedOut)?;
 //!
 //!     loop {
-//!         match serial.read() {
+//!         match serial.try_read() {
 //!             // raise error
 //!             Err(nb::Error::Other(e)) => return Err(Error::Serial(e)),
 //!             Err(nb::Error::WouldBlock) => {
@@ -608,7 +608,7 @@
 //! {
 //!     loop {
 //!         if let Some(byte) = cb.peek() {
-//!             match serial.write(*byte) {
+//!             match serial.try_write(*byte) {
 //!                 Err(nb::Error::Other(_)) => unreachable!(),
 //!                 Err(nb::Error::WouldBlock) => return,
 //!                 Ok(()) => {}, // keep flushing data
@@ -670,8 +670,8 @@
 //! # struct Serial1;
 //! # impl ::hal::serial::Write<u8> for Serial1 {
 //! #   type Error = Infallible;
-//! #   fn write(&mut self, _: u8) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
-//! #   fn flush(&mut self) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
+//! #   fn try_write(&mut self, _: u8) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
+//! #   fn try_flush(&mut self) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
 //! # }
 //! # struct CircularBuffer;
 //! # impl CircularBuffer {

diff --git a/src/serial.rs b/src/serial.rs
@@ -11,7 +11,7 @@ pub trait Read<Word> {
     type Error;
 
     /// Reads a single word from the serial interface
-    fn read(&mut self) -> nb::Result<Word, Self::Error>;
+    fn try_read(&mut self) -> nb::Result<Word, Self::Error>;
 }
 
 /// Write half of a serial interface
@@ -20,8 +20,8 @@ pub trait Write<Word> {
     type Error;
 
     /// Writes a single word to the serial interface
-    fn write(&mut self, word: Word) -> nb::Result<(), Self::Error>;
+    fn try_write(&mut self, word: Word) -> nb::Result<(), Self::Error>;
 
     /// Ensures that none of the previously written words are still buffered
-    fn flush(&mut self) -> nb::Result<(), Self::Error>;
+    fn try_flush(&mut self) -> nb::Result<(), Self::Error>;
 }