Struct ockam_core::api::Response

pub struct Response<T = ()> { /* private fields */ }

Implementations

impl<T> Response<T>

pub fn id(self, id: Id) -> Self

pub fn re(self, re: Id) -> Self

Setter for the Request Id on the ResponseHeader

pub fn status(self, s: Status) -> Self

pub fn header(&self) -> &ResponseHeader

pub fn into_parts(self) -> (ResponseHeader, Option<T>)

pub fn with_headers(self, req: &RequestHeader) -> Self

Convenient wrapper to append the requests header to the response

impl Response<()>

pub fn body<T: Encode<()>>(self, b: T) -> Response<T>

impl Response

These functions create standard responses

pub fn error(r: &RequestHeader, msg: &str, status: Status) -> Response<Error>

pub fn ok() -> Response

pub fn bad_request_no_request(msg: &str) -> Response<Error>

pub fn bad_request(r: &RequestHeader, msg: &str) -> Response<Error>

Create a generic bad request response.

pub fn not_found(r: &RequestHeader, msg: &str) -> Response<Error>

pub fn not_found_no_request(msg: &str) -> Response<Error>

pub fn not_implemented(re: Id) -> Response

pub fn unauthorized(re: Id) -> Response

pub fn forbidden_no_request(re: Id) -> Response

pub fn forbidden(r: &RequestHeader, m: &str) -> Response<Error>

Create an error response with status forbidden and the given message.

pub fn internal_error_no_request(msg: &str) -> Response<Error>

pub fn internal_error(r: &RequestHeader, msg: &str) -> Response<Error>

Create an internal server error response

pub fn unknown_path(r: &RequestHeader) -> Response<Error>

Create an error response because the request path was unknown.

pub fn invalid_method(r: &RequestHeader) -> Response<Error>

Create an error response because the request method was unknown or not allowed.

impl Response

pub fn parse_response_body<T>(bytes: &[u8]) -> Result<T>

where T: for<'a> Decode<'a, ()>,

Parse the response header and if it is ok parse and decode the response body

pub fn parse_response_reply<T>(bytes: &[u8]) -> Result<Reply<T>>

where T: for<'a> Decode<'a, ()>,

Parse the response header and if it is ok parse the response body

pub fn parse_response_header( bytes: &[u8], ) -> Result<(ResponseHeader, Decoder<'_>)>

Parse the response header and return it + the Decoder to continue parsing if necessary

impl<T: Encode<()>> Response<T>

pub fn encode<W>(&self, buf: W) -> Result<(), Error<W::Error>>

where W: Write,

pub fn to_vec(self) -> Result<Vec<u8>, Error<<Vec<u8> as Write>::Error>>

Trait Implementations

impl<T: Debug> Debug for Response<T>

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

Formats the value using the given formatter.

impl From<Error> for Response<Error>

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Response<Error>

fn from(e: Error) -> Self

Converts to this type from the input type.