Struct HyperHttpProtocol 

pub struct HyperHttpProtocol { /* private fields */ }

Implementations

impl HyperHttpProtocol

pub async fn route( self, router: Arc<Router<Self>>, context_data: HashMap<String, Box<dyn Any + Send>>, ) -> Result<Response<BoxBody<Bytes, Infallible>>, Infallible>

Methods from Deref<Target = Meta<Request<Incoming>, Response<BoxBody<Bytes, Infallible>>>>

pub fn req(&self) -> Result<&Req, DceErr>

pub fn req_mut(&mut self) -> &mut Option<Req>

pub fn resp_mut(&mut self) -> &mut Option<Response<Resp>>

pub fn heads(&self) -> &HashMap<String, String>

pub fn resp_heads(&self) -> &HashMap<String, String>

pub fn resp_heads_mut(&mut self) -> &mut HashMap<String, String>

Trait Implementations

impl Debug for HyperHttpProtocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for HyperHttpProtocol

type Target = Meta<Request<Incoming>, Response<BoxBody<Bytes, Infallible>>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for HyperHttpProtocol

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Request<Incoming>> for HyperHttpProtocol

fn from(value: Request<Incoming>) -> Self

Converts to this type from the input type.

impl HttpMethodGetter for HyperHttpProtocol

fn method(&self) -> &Method

impl HttpProtocol for HyperHttpProtocol

fn parse_http_method( prop_mapping: &mut HashMap<&'static str, Box<dyn Any + Send + Sync>>, ) -> Option<Box<dyn DceMethod<Self> + Send + Sync>>

impl Into<Response<BoxBody<Bytes, Infallible>>> for HyperHttpProtocol

fn into(self) -> Response<BoxBody<Bytes, Infallible>>

Converts this type into the (usually inferred) input type.

impl RoutableProtocol for HyperHttpProtocol

type Req = Request<Incoming>

type Resp = Response<BoxBody<Bytes, Infallible>>

fn body<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = DceResult<Serialized>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn pack_resp(&self, serialized: Serialized) -> Self::Resp

fn path(&self) -> &str

fn handle_result( self, result: DceResult<()>, _: &mut Context<Self>, ) -> Option<Self::Resp>

fn parse_api_method( prop_mapping: &mut HashMap<&'static str, Box<dyn Any + Send + Sync>>, ) -> Option<Box<dyn DceMethod<Self> + Send + Sync>>

fn id(&self) -> Option<&str>

fn handle<'async_trait>( self, router: Arc<Router<Self>>, context_data: HashMap<String, Box<dyn Any + Send>>, ) -> Pin<Box<dyn Future<Output = Option<Self::Resp>> + Send + 'async_trait>>

where Self: Send + 'async_trait,

fn api_match( &self, apis: &[&'static (dyn ApiTrait<Self> + Send + Sync)], ) -> Result<&'static (dyn ApiTrait<Self> + Send + Sync), DceErr>

fn deserializer<'a, ReqDto>( deserializers: &'a [Box<dyn Deserializer<ReqDto> + Send + Sync>], _context: &Context<Self>, ) -> Result<&'a Box<dyn Deserializer<ReqDto> + Send + Sync>, DceErr>

fn serializer<'a, RespDto>( serializers: &'a [Box<dyn Serializer<RespDto> + Send + Sync>], _context: &Context<Self>, ) -> Result<&'a Box<dyn Serializer<RespDto> + Send + Sync>, DceErr>

fn deserialize<ReqDto>( serializers: &[Box<dyn Deserializer<ReqDto> + Send + Sync>], seq: Serialized, context: &Context<Self>, ) -> Result<ReqDto, DceErr>

fn serialize<RespDto>( serializers: &[Box<dyn Serializer<RespDto> + Send + Sync>], dto: Serializable<RespDto>, context: &Context<Self>, ) -> Result<Serialized, DceErr>

fn pack_responsible<RespDto>( context: &Context<Self>, serializers: &[Box<dyn Serializer<RespDto> + Send + Sync>], responsible: Serializable<RespDto>, ) -> Result<Option<Response<Self::Resp>>, DceErr>

where RespDto: 'static,

fn parse_api_method_and_extras( prop_tuples: Vec<(&'static str, Box<dyn Any + Send + Sync>)>, ) -> (Option<Box<dyn Method<Self> + Send + Sync>>, HashMap<&'static str, Box<dyn Any + Send + Sync>>)

fn try_print_err(response: &Result<(), DceErr>)

fn err_into(self, err: DceErr) -> Self::Resp