use std::{fmt, future::Future, pin::Pin, task::Context, task::Poll};
use crate::ctx::{ServiceCtx, WaitersRef};
pub type BoxFuture<'a, I, E> = Pin<Box<dyn Future<Output = Result<I, E>> + 'a>>;
pub struct BoxService<Req, Res, Err>(Box<dyn ServiceObj<Req, Response = Res, Error = Err>>);
pub struct BoxServiceFactory<Cfg, Req, Res, Err, InitErr>(
Box<dyn ServiceFactoryObj<Req, Cfg, Response = Res, Error = Err, InitError = InitErr>>,
);
pub fn factory<F, R, C>(
factory: F,
) -> BoxServiceFactory<C, R, F::Response, F::Error, F::InitError>
where
R: 'static,
C: 'static,
F: crate::ServiceFactory<R, C> + 'static,
F::Service: 'static,
{
BoxServiceFactory(Box::new(factory))
}
pub fn service<S, R>(service: S) -> BoxService<R, S::Response, S::Error>
where
R: 'static,
S: crate::Service<R> + 'static,
{
BoxService(Box::new(service))
}
impl<Req, Res, Err> fmt::Debug for BoxService<Req, Res, Err> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BoxService").finish()
}
}
impl<Cfg, Req, Res, Err, InitErr> fmt::Debug
for BoxServiceFactory<Cfg, Req, Res, Err, InitErr>
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BoxServiceFactory").finish()
}
}
trait ServiceObj<Req> {
type Response;
type Error;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;
fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()>;
fn call<'a>(
&'a self,
req: Req,
idx: usize,
waiters: &'a WaitersRef,
) -> BoxFuture<'a, Self::Response, Self::Error>;
}
impl<S, Req> ServiceObj<Req> for S
where
Req: 'static,
S: crate::Service<Req>,
{
type Response = S::Response;
type Error = S::Error;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
crate::Service::poll_ready(self, cx)
}
fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
crate::Service::poll_shutdown(self, cx)
}
#[inline]
fn call<'a>(
&'a self,
req: Req,
idx: usize,
waiters: &'a WaitersRef,
) -> BoxFuture<'a, Self::Response, Self::Error> {
Box::pin(async move {
ServiceCtx::<'a, S>::from_ref(idx, waiters)
.call_nowait(self, req)
.await
})
}
}
trait ServiceFactoryObj<Req, Cfg> {
type Response;
type Error;
type InitError;
fn create<'a>(
&'a self,
cfg: Cfg,
) -> BoxFuture<'a, BoxService<Req, Self::Response, Self::Error>, Self::InitError>
where
Cfg: 'a;
}
impl<F, Req, Cfg> ServiceFactoryObj<Req, Cfg> for F
where
Cfg: 'static,
Req: 'static,
F: crate::ServiceFactory<Req, Cfg>,
F::Service: 'static,
{
type Response = F::Response;
type Error = F::Error;
type InitError = F::InitError;
#[inline]
fn create<'a>(
&'a self,
cfg: Cfg,
) -> BoxFuture<'a, BoxService<Req, Self::Response, Self::Error>, Self::InitError>
where
Cfg: 'a,
{
let fut = crate::ServiceFactory::create(self, cfg);
Box::pin(async move { fut.await.map(service) })
}
}
impl<Req, Res, Err> crate::Service<Req> for BoxService<Req, Res, Err>
where
Req: 'static,
{
type Response = Res;
type Error = Err;
#[inline]
fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.poll_ready(ctx)
}
#[inline]
fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
self.0.poll_shutdown(cx)
}
#[inline]
async fn call(&self, req: Req, ctx: ServiceCtx<'_, Self>) -> Result<Res, Err> {
let (idx, waiters) = ctx.inner();
self.0.call(req, idx, waiters).await
}
}
impl<C, Req, Res, Err, InitErr> crate::ServiceFactory<Req, C>
for BoxServiceFactory<C, Req, Res, Err, InitErr>
where
Req: 'static,
{
type Response = Res;
type Error = Err;
type Service = BoxService<Req, Res, Err>;
type InitError = InitErr;
#[inline]
async fn create(&self, cfg: C) -> Result<Self::Service, Self::InitError> {
self.0.create(cfg).await
}
}