ntex-grpc 0.2.0-b.2

use async_trait::async_trait;
use ntex_bytes::{ByteString, Bytes, BytesMut};

use crate::request::{RequestContext, Response};
use crate::{error::DecodeError, error::HttpError, types::Message};

/// Trait for service method definition
pub trait ServiceDef {
    const NAME: &'static str;

    type Methods: MethodsDef;

    #[inline]
    fn method_by_name(name: &str) -> Option<Self::Methods> {
        <Self::Methods as MethodsDef>::by_name(name)
    }
}

/// Service methods
pub trait MethodsDef: Sized {
    fn by_name(name: &str) -> Option<Self>;
}

/// Trait for service method definition
pub trait MethodDef {
    const NAME: &'static str;

    const PATH: ByteString;

    type Input: Message;

    type Output: Message;

    #[inline]
    fn decode(&self, buf: &mut Bytes) -> Result<Self::Input, DecodeError> {
        Message::read(buf)
    }

    #[inline]
    fn encode(&self, val: Self::Output, buf: &mut BytesMut) {
        val.write(buf);
    }
}

#[async_trait(?Send)]
pub trait Transport<T: MethodDef> {
    /// Errors produced by the service.
    type Error: From<HttpError>;

    async fn request(
        &self,
        args: &T::Input,
        ctx: RequestContext,
    ) -> Result<Response<T>, Self::Error>;
}

/// Client utils methods
pub trait ClientInformation<T> {
    /// Create new client instance
    fn create(transport: T) -> Self;

    /// Get reference to underlying transport
    fn transport(&self) -> &T;

    /// Get mut referece to underlying transport
    fn transport_mut(&mut self) -> &mut T;

    /// Consume client and return inner transport
    fn into_inner(self) -> T;
}