remove remaining 'context lifetimes

Author: ZoeyR

src/de/decoder.rs

@@ -99,22 +99,22 @@ impl<R: Reader, C: Config, Context> Decoder for DecoderImpl<R, C, Context> {
     }
 }
 
-pub struct WithContext<'a, 'context, D: ?Sized, C> {
+pub struct WithContext<'a, D: ?Sized, C> {
     pub(crate) decoder: &'a mut D,
-    pub(crate) context: &'context mut C,
+    pub(crate) context: C,
 }
 
-impl<C, D: Decoder + ?Sized> Sealed for WithContext<'_, '_, D, C> {}
+impl<C, D: Decoder + ?Sized> Sealed for WithContext<'_, D, C> {}
 
-impl<Context, D: Decoder + ?Sized> Decoder for WithContext<'_, '_, D, Context> {
+impl<Context, D: Decoder + ?Sized> Decoder for WithContext<'_, D, Context> {
     type R = D::R;
 
     type C = D::C;
 
     type Context = Context;
 
     fn context(&mut self) -> &mut Self::Context {
-        self.context
+        &mut self.context
     }
 
     fn reader(&mut self) -> &mut Self::R {
@@ -134,7 +134,7 @@ impl<Context, D: Decoder + ?Sized> Decoder for WithContext<'_, '_, D, Context> {
     }
 }
 
-impl<'de, C, D: BorrowDecoder<'de>> BorrowDecoder<'de> for WithContext<'_, '_, D, C> {
+impl<'de, C, D: BorrowDecoder<'de>> BorrowDecoder<'de> for WithContext<'_, D, C> {
     type BR = D::BR;
     fn borrow_reader(&mut self) -> &mut Self::BR {
         self.decoder.borrow_reader()

src/de/mod.rs

@@ -25,7 +25,7 @@ pub use self::decoder::DecoderImpl;
 ///
 /// This trait should be implemented for types which do not have references to data in the reader. For types that contain e.g. `&str` and `&[u8]`, implement [BorrowDecode] instead.
 ///
-/// Whenever you implement `Decode` for your type, the base trait `BorrowDecode` is automatically implemented.
+/// Whenever you derive `Decode` for your type, the base trait `BorrowDecode` is automatically implemented.
 ///
 /// This trait will be automatically implemented with unbounded `Context` if you enable the `derive` feature and add `#[derive(bincode::Decode)]` to your type. Note that if the type contains any lifetimes, `BorrowDecode` will be implemented instead.
 ///
@@ -131,6 +131,7 @@ macro_rules! impl_borrow_decode {
     };
 }
 
+/// Helper macro to implement `BorrowDecode` for any type that implements `Decode`.
 #[macro_export]
 macro_rules! impl_borrow_decode_with_context {
     ($ty:ty, $context:ty $(, $param:tt)*) => {
@@ -158,10 +159,8 @@ pub trait Decoder: Sealed {
     /// Returns the decoding context
     fn context(&mut self) -> &mut Self::Context;
 
-    fn with_context<'a, 'context, C>(
-        &'a mut self,
-        context: &'context mut C,
-    ) -> WithContext<'a, 'context, Self, C> {
+    /// Wraps decoder with a context
+    fn with_context<'a, C>(&'a mut self, context: C) -> WithContext<'a, Self, C> {
         WithContext {
             decoder: self,
             context,

src/features/impl_std.rs

@@ -30,6 +30,11 @@ pub fn decode_from_std_read<D: Decode<()>, C: Config, R: std::io::Read>(
     decode_from_std_read_with_context(src, config, ())
 }
 
+/// Decode type `D` from the given reader with the given `Config` and `Context`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
+///
+/// See the [config] module for more information about config options.
+///
+/// [config]: config/index.html
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 pub fn decode_from_std_read_with_context<
     Context,

src/features/serde/de_owned.rs

@@ -24,35 +24,28 @@ impl<DE: Decoder> OwnedSerdeDecoder<DE> {
 }
 
 #[cfg(feature = "std")]
-impl<'r, C: Config, R: std::io::Read, Context>
-    OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, Context>>
-{
+impl<'r, C: Config, R: std::io::Read> OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, ()>> {
     /// Creates the decoder from an `std::io::Read` implementor.
     pub fn from_std_read(
         src: &'r mut R,
         config: C,
-        context: Context,
-    ) -> OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, Context>>
+    ) -> OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, ()>>
     where
         C: Config,
     {
         let reader = IoReader::new(src);
-        let decoder = DecoderImpl::new(reader, config, context);
+        let decoder = DecoderImpl::new(reader, config, ());
         Self { de: decoder }
     }
 }
 
-impl<C: Config, R: Reader, Context> OwnedSerdeDecoder<DecoderImpl<R, C, Context>> {
+impl<C: Config, R: Reader> OwnedSerdeDecoder<DecoderImpl<R, C, ()>> {
     /// Creates the decoder from a [`Reader`] implementor.
-    pub fn from_reader(
-        reader: R,
-        config: C,
-        context: Context,
-    ) -> OwnedSerdeDecoder<DecoderImpl<R, C, Context>>
+    pub fn from_reader(reader: R, config: C) -> OwnedSerdeDecoder<DecoderImpl<R, C, ()>>
     where
         C: Config,
     {
-        let decoder = DecoderImpl::new(reader, config, context);
+        let decoder = DecoderImpl::new(reader, config, ());
         Self { de: decoder }
     }
 }
@@ -85,11 +78,7 @@ pub fn decode_from_std_read<'r, D: DeserializeOwned, C: Config, R: std::io::Read
     config: C,
 ) -> Result<D, DecodeError> {
     let mut serde_decoder =
-        OwnedSerdeDecoder::<DecoderImpl<IoReader<&'r mut R>, C, ()>>::from_std_read(
-            src,
-            config,
-            (),
-        );
+        OwnedSerdeDecoder::<DecoderImpl<IoReader<&'r mut R>, C, ()>>::from_std_read(src, config);
     D::deserialize(serde_decoder.as_deserializer())
 }
 
@@ -102,8 +91,7 @@ pub fn decode_from_reader<D: DeserializeOwned, R: Reader, C: Config>(
     reader: R,
     config: C,
 ) -> Result<D, DecodeError> {
-    let mut serde_decoder =
-        OwnedSerdeDecoder::<DecoderImpl<R, C, ()>>::from_reader(reader, config, ());
+    let mut serde_decoder = OwnedSerdeDecoder::<DecoderImpl<R, C, ()>>::from_reader(reader, config);
     D::deserialize(serde_decoder.as_deserializer())
 }
 

src/lib.rs

@@ -1,5 +1,5 @@
 #![no_std]
-#![warn(unused_lifetimes)]
+#![warn(missing_docs, unused_lifetimes)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 //! Bincode is a crate for encoding and decoding using a tiny binary
@@ -152,6 +152,13 @@ pub fn decode_from_slice<D: de::Decode<()>, C: Config>(
     decode_from_slice_with_context(src, config, ())
 }
 
+/// Attempt to decode a given type `D` from the given slice with `Context`. Returns the decoded output and the amount of bytes read.
+///
+/// Note that this does not work with borrowed types like `&str` or `&[u8]`. For that use [borrow_decode_from_slice].
+///
+/// See the [config] module for more information on configurations.
+///
+/// [config]: config/index.html
 pub fn decode_from_slice_with_context<Context, D: de::Decode<Context>, C: Config>(
     src: &[u8],
     config: C,
@@ -176,6 +183,11 @@ pub fn borrow_decode_from_slice<'a, D: de::BorrowDecode<'a, ()>, C: Config>(
     borrow_decode_from_slice_with_context(src, config, ())
 }
 
+/// Attempt to decode a given type `D` from the given slice with `Context`. Returns the decoded output and the amount of bytes read.
+///
+/// See the [config] module for more information on configurations.
+///
+/// [config]: config/index.html
 pub fn borrow_decode_from_slice_with_context<
     'a,
     Context,

tests/context.rs

@@ -80,8 +80,8 @@ impl<Context> Decode<Context> for SelfReferencing {
     fn decode<D: bincode::de::Decoder<Context = Context>>(
         decoder: &mut D,
     ) -> Result<Self, DecodeError> {
-        SelfReferencing::try_new(Bump::new(), |mut bump| {
-            Container::decode(&mut decoder.with_context(&mut bump))
+        SelfReferencing::try_new(Bump::new(), |bump| {
+            Container::decode(&mut decoder.with_context(bump))
         })
     }
 }