rename capnp_futures::serialize::read_message to capnp::futures::serialize::try_read_message, for consistency with capnp::serialize

Author: dwrensha

capnp-futures/src/read_stream.rs

@@ -30,7 +30,7 @@ async fn read_next_message<R>(mut reader: R, options: message::ReaderOptions)
                               -> Result<(R, Option<message::Reader<capnp::serialize::OwnedSegments>>), Error>
     where R: AsyncRead + Unpin
 {
-    let m = crate::serialize::read_message(&mut reader, options).await?;
+    let m = crate::serialize::try_read_message(&mut reader, options).await?;
     Ok((reader, m))
 }
 

capnp-futures/src/serialize.rs

@@ -28,11 +28,19 @@ use capnp::serialize::{OwnedSegments, SegmentLengthsBuilder};
 
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
+#[deprecated(since = "0.13.2", note = "This function was renamed to try_read_message()")]
+pub async fn read_message<R>(reader: R, options: message::ReaderOptions) -> Result<Option<message::Reader<OwnedSegments>>>
+    where R: AsyncRead + Unpin
+{
+    try_read_message(reader, options).await
+}
+
+
 /// Begins an asynchronous read of a message from `reader`. Returns `None` if
 /// `reader` has zero bytes left (i.e. is at end-of-file). To read a stream
 /// containing an unknown number of messages, you could call this function
 /// repeatedly until it returns `None`.
-pub async fn read_message<R>(mut reader: R, options: message::ReaderOptions) -> Result<Option<message::Reader<OwnedSegments>>>
+pub async fn try_read_message<R>(mut reader: R, options: message::ReaderOptions) -> Result<Option<message::Reader<OwnedSegments>>>
     where R: AsyncRead + Unpin
 {
     let segment_lengths_builder = match read_segment_table(&mut reader, options).await? {
@@ -228,7 +236,7 @@ pub mod test {
 
     use super::{
         AsOutputSegments,
-        read_message,
+        try_read_message,
         read_segment_table,
         write_message,
     };
@@ -494,7 +502,7 @@ pub mod test {
             };
 
             let message =
-                futures::executor::block_on(Box::pin(read_message(&mut read, Default::default()))).expect("reading").unwrap();
+                futures::executor::block_on(Box::pin(try_read_message(&mut read, Default::default()))).expect("reading").unwrap();
             let message_segments = message.into_segments();
 
             TestResult::from_bool(segments.iter().enumerate().all(|(i, segment)| {

capnp-futures/test/test.rs

@@ -130,7 +130,7 @@ mod tests {
         let f0 = serialize::write_message(stream0, message)
                 .map_err(|e| panic!("write error {:?}", e)).map(|_|());
         let f1 =
-            serialize::read_message(stream1, capnp::message::ReaderOptions::new()).and_then(|maybe_message_reader| {
+            serialize::try_read_message(stream1, capnp::message::ReaderOptions::new()).and_then(|maybe_message_reader| {
                 match maybe_message_reader {
                     None => panic!("did not get message"),
                     Some(m) => {
@@ -161,7 +161,7 @@ mod tests {
     #[test]
     fn static_lifetime_not_required_funcs() {
         let (mut write, mut read) = async_byte_channel::channel();
-        let _ = serialize::read_message(&mut read, message::ReaderOptions::default());
+        let _ = serialize::try_read_message(&mut read, message::ReaderOptions::default());
         let _ = serialize::write_message(&mut write, message::Builder::new_default());
     }
 

capnp-rpc/src/twoparty.rs

@@ -149,7 +149,7 @@ impl <T> crate::Connection<crate::rpc_twoparty_capnp::Side> for Connection<T>
             Some(mut s) => {
                 let receive_options = inner.receive_options;
                 Promise::from_future(async move {
-                    let maybe_message = ::capnp_futures::serialize::read_message(&mut s, receive_options).await?;
+                    let maybe_message = ::capnp_futures::serialize::try_read_message(&mut s, receive_options).await?;
                     *return_it_here.borrow_mut() = Some(s);
                     Ok(maybe_message.map(|message|
                                          Box::new(IncomingMessage::new(message)) as Box<dyn crate::IncomingMessage>))