Struct HyperProtocol 

pub struct HyperProtocol { /* private fields */ }

Implementations

impl HyperProtocol

pub fn sid(&self) -> Option<&str>

pub async fn handle( self, routed: DceResult<RouteMatch<'_, HyperProtocol>>, ) -> Result<Response<BoxBody<Bytes, Infallible>>, Infallible>

Methods from Deref<Target = RpMeta<Request<Incoming>>>

pub fn raw(&self) -> &Req

pub fn raw_mut(&mut self) -> &mut Req

pub fn clear_buffer(&mut self) -> Vec<u8>

pub fn is_resp_empty(&self) -> bool

pub fn write(&mut self, bytes: Bytes)

pub fn write_string(&mut self, str: String)

pub fn set_ctx_data(&mut self, key: String, value: Box<dyn Any + Send>)

pub fn ctx_data(&self, key: &str) -> Option<&Box<dyn Any + Send>>

pub fn ctx_data_remove(&mut self, key: &str) -> Option<Box<dyn Any + Send>>

pub fn sid(&self) -> Option<&str>

pub fn set_session(&mut self)

pub fn session(&self)

pub fn set_resp_sid(&mut self, sid: String)

pub fn resp_sid(&self) -> Option<&str>

Trait Implementations

impl Deref for HyperProtocol

type Target = RpMeta<Request<Incoming>>

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for HyperProtocol

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

Mutably dereferences the value.

impl RoutableProtocol for HyperProtocol

type Req = Request<Incoming>

fn path(&self) -> &str

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

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

fn match_api( &self, apis: &Vec<&'static Api<Self>>, ) -> Option<&'static Api<Self>>

fn id(&self) -> isize

fn sync_body(&mut self) -> Result<Bytes, DceError>

fn sync_body_string(&mut self) -> Result<String, DceError>

fn body_string<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<String, DceError>> + Send + 'async_trait>>

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

fn try_print_err(&self, err: &Option<DceError>)