Remove unneeded boxed types

ntex-io/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.1.2] - 2022-01-10
+
+* Remove unneeded boxed types
+
+* Add Framed::into_inner() helper method
+
 ## [0.1.1] - 2022-01-03
 
 * Move tokio support to separate crate

ntex-io/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,7 +18,7 @@ path = "src/lib.rs"
 [dependencies]
 ntex-codec = "0.6.0"
 ntex-bytes = "0.1.8"
-ntex-util = "0.1.6"
+ntex-util = "0.1.8"
 ntex-service = "0.3.1"
 
 bitflags = "1.3"

ntex-io/src/dispatcher.rs

@@ -93,9 +93,10 @@ where
     U: Decoder + Encoder + 'static,
 {
     /// Construct new `Dispatcher` instance.
-    pub fn new<Io, F: IntoService<S, DispatchItem<U>>>(io: Io, codec: U, service: F) -> Self
+    pub fn new<Io, F>(io: Io, codec: U, service: F) -> Self
     where
         IoBoxed: From<Io>,
+        F: IntoService<S, DispatchItem<U>>,
     {
         let io = IoBoxed::from(io);
         let ka_timeout = Cell::new(Seconds(30).into());

ntex-io/src/framed.rs

@@ -13,10 +13,7 @@ pub struct Framed<U> {
     codec: U,
 }
 
-impl<U> Framed<U>
-where
-    U: Decoder + Encoder,
-{
+impl<U> Framed<U> {
     #[inline]
     /// Provides an interface for reading and writing to
     /// `Io` object, using `Decode` and `Encode` traits of codec.
@@ -42,6 +39,17 @@ where
         &self.codec
     }
 
+    #[inline]
+    /// Return inner types of framed object
+    pub fn into_inner(self) -> (IoBoxed, U) {
+        (self.io, self.codec)
+    }
+}
+
+impl<U> Framed<U>
+where
+    U: Decoder + Encoder,
+{
     #[inline]
     /// Wake write task and instruct to flush data.
     ///
@@ -68,17 +76,6 @@ where
     }
 }
 
-impl<U> fmt::Debug for Framed<U>
-where
-    U: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Framed")
-            .field("codec", &self.codec)
-            .finish()
-    }
-}
-
 impl<U> Framed<U>
 where
     U: Encoder,
@@ -93,6 +90,17 @@ where
     }
 }
 
+impl<U> fmt::Debug for Framed<U>
+where
+    U: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Framed")
+            .field("codec", &self.codec)
+            .finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use ntex_bytes::Bytes;

ntex-io/src/lib.rs

@@ -16,7 +16,7 @@ mod ioref;
 mod seal;
 mod tasks;
 mod timer;
-pub mod utils;
+mod utils;
 
 use ntex_bytes::BytesMut;
 use ntex_codec::{Decoder, Encoder};
@@ -24,10 +24,11 @@ use ntex_util::time::Millis;
 
 pub use self::dispatcher::Dispatcher;
 pub use self::filter::Base;
-pub use self::io::{Io, IoRef};
+pub use self::framed::Framed;
+pub use self::io::{Io, IoRef, OnDisconnect};
 pub use self::seal::{IoBoxed, Sealed};
 pub use self::tasks::{ReadContext, WriteContext};
-pub use self::utils::filter;
+pub use self::utils::{filter, seal};
 
 /// Status for read task
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]

ntex-io/src/types.rs

@@ -1,3 +1,4 @@
+//! Query related types
 use std::{any, fmt, marker::PhantomData, net::SocketAddr};
 
 #[derive(Copy, Clone, PartialEq, Eq)]

ntex-io/src/utils.rs

@@ -1,10 +1,8 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{marker::PhantomData, task::Context, task::Poll};
 
 use ntex_service::{fn_factory_with_config, into_service, Service, ServiceFactory};
-use ntex_util::{future::Ready, ready};
+use ntex_util::future::Ready;
 
-pub use crate::framed::Framed;
-pub use crate::io::OnDisconnect;
 use crate::{Filter, FilterFactory, Io, IoBoxed};
 
 /// Service that converts any Io<F> stream to IoBoxed stream
@@ -30,18 +28,6 @@ where
     })
 }
 
-/// Service that converts Io<F> responses from service to the IoBoxed
-pub fn boxed<S, R, F>(inner: S) -> Boxed<S, R>
-where
-    F: Filter,
-    S: Service<R, Response = Io<F>>,
-{
-    Boxed {
-        inner,
-        _t: PhantomData,
-    }
-}
-
 /// Create filter factory service
 pub fn filter<T, F>(filter: T) -> FilterServiceFactory<T, F>
 where
@@ -54,126 +40,6 @@ where
     }
 }
 
-pub struct BoxedFactory<S, R> {
-    inner: S,
-    _t: PhantomData<R>,
-}
-
-impl<S, R> BoxedFactory<S, R> {
-    pub fn new(inner: S) -> Self {
-        Self {
-            inner,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<S: Clone, R> Clone for BoxedFactory<S, R> {
-    fn clone(&self) -> Self {
-        Self::new(self.inner.clone())
-    }
-}
-
-impl<S, R, C, F> ServiceFactory<R, C> for BoxedFactory<S, R>
-where
-    F: Filter,
-    S: ServiceFactory<R, C, Response = Io<F>>,
-{
-    type Response = IoBoxed;
-    type Error = S::Error;
-    type Service = Boxed<S::Service, R>;
-    type InitError = S::InitError;
-    type Future = BoxedFactoryResponse<S, R, C>;
-
-    fn new_service(&self, cfg: C) -> Self::Future {
-        BoxedFactoryResponse {
-            fut: self.inner.new_service(cfg),
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct Boxed<S, R> {
-    inner: S,
-    _t: PhantomData<R>,
-}
-
-impl<S, R> Boxed<S, R> {
-    pub fn new(inner: S) -> Self {
-        Self {
-            inner,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<S: Clone, R> Clone for Boxed<S, R> {
-    fn clone(&self) -> Self {
-        Self::new(self.inner.clone())
-    }
-}
-
-impl<S, R, F> Service<R> for Boxed<S, R>
-where
-    F: Filter,
-    S: Service<R, Response = Io<F>>,
-{
-    type Response = IoBoxed;
-    type Error = S::Error;
-    type Future = BoxedResponse<S, R>;
-
-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    #[inline]
-    fn poll_shutdown(&self, cx: &mut Context<'_>, is_err: bool) -> Poll<()> {
-        self.inner.poll_shutdown(cx, is_err)
-    }
-
-    fn call(&self, req: R) -> Self::Future {
-        BoxedResponse {
-            fut: self.inner.call(req),
-        }
-    }
-}
-
-pin_project_lite::pin_project! {
-    #[doc(hidden)]
-    pub struct BoxedFactoryResponse<S: ServiceFactory<R, C>, R, C> {
-        #[pin]
-        fut: S::Future,
-        _t: PhantomData<(R, C)>
-    }
-}
-
-impl<S: ServiceFactory<R, C>, R, C> Future for BoxedFactoryResponse<S, R, C> {
-    type Output = Result<Boxed<S::Service, R>, S::InitError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Poll::Ready(ready!(self.project().fut.poll(cx)).map(|inner| Boxed {
-            inner,
-            _t: PhantomData,
-        }))
-    }
-}
-
-pin_project_lite::pin_project! {
-    #[doc(hidden)]
-    pub struct BoxedResponse<S: Service<R>, R> {
-        #[pin]
-        fut: S::Future,
-    }
-}
-
-impl<S: Service<R, Response = Io<F>>, R, F: Filter> Future for BoxedResponse<S, R> {
-    type Output = Result<IoBoxed, S::Error>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Poll::Ready(ready!(self.project().fut.poll(cx)).map(IoBoxed::from))
-    }
-}
-
 pub struct FilterServiceFactory<T, F> {
     filter: T,
     _t: PhantomData<F>,