Struct hyper_staticfile::ResponseBuilder

source ·

pub struct ResponseBuilder<'a> {
    pub path: &'a str,
    pub query: Option<&'a str>,
    pub file_response_builder: FileResponseBuilder,
}

Expand description

Utility to build the default response for a resolve result.

This struct allows direct access to its fields, but these fields are typically initialized by the accessors, using the builder pattern. The fields are basically a bunch of settings that determine the response details.

Fields§

§path: &'a str

The request path.

§query: Option<&'a str>

The request query string.

§file_response_builder: FileResponseBuilder

Inner file response builder.

Implementations§

source §

impl<'a> ResponseBuilder<'a>

source

pub fn new() -> Self

Create a new builder with a default configuration.

Examples found in repository ?

src/service.rs (line 57)

    pub async fn serve<B>(self, request: Request<B>) -> Result<Response<Body>, IoError> {
        let Self {
            root,
            cache_headers,
        } = self;
        resolve(root, &request).await.map(|result| {
            ResponseBuilder::new()
                .request(&request)
                .cache_headers(cache_headers)
                .build(result)
                .expect("unable to build response")
        })
    }

source

pub fn request(&mut self, req: &'a Request) -> &mut Self

Apply parameters based on a request.

Examples found in repository ?

src/service.rs (line 58)

    pub async fn serve<B>(self, request: Request<B>) -> Result<Response<Body>, IoError> {
        let Self {
            root,
            cache_headers,
        } = self;
        resolve(root, &request).await.map(|result| {
            ResponseBuilder::new()
                .request(&request)
                .cache_headers(cache_headers)
                .build(result)
                .expect("unable to build response")
        })
    }

source

pub fn request_parts(
    &mut self,
    method: &Method,
    uri: &'a Uri,
    headers: &'a HeaderMap
) -> &mut Self

Apply parameters based on request parts.

Examples found in repository ?

src/response_builder.rs (line 30)

    pub fn request<B>(&mut self, req: &'a Request<B>) -> &mut Self {
        self.request_parts(req.method(), req.uri(), req.headers());
        self
    }

source

pub fn request_uri(&mut self, uri: &'a Uri) -> &mut Self

Apply parameters based on a request URI.

Examples found in repository ?

src/response_builder.rs (line 41)

    pub fn request_parts(
        &mut self,
        method: &Method,
        uri: &'a Uri,
        headers: &'a HeaderMap,
    ) -> &mut Self {
        self.request_uri(uri);
        self.file_response_builder.request_parts(method, headers);
        self
    }

source

pub fn cache_headers(&mut self, value: Option<u32>) -> &mut Self

Add cache headers to responses for the given lifespan.

Examples found in repository ?

src/service.rs (line 59)

    pub async fn serve<B>(self, request: Request<B>) -> Result<Response<Body>, IoError> {
        let Self {
            root,
            cache_headers,
        } = self;
        resolve(root, &request).await.map(|result| {
            ResponseBuilder::new()
                .request(&request)
                .cache_headers(cache_headers)
                .build(result)
                .expect("unable to build response")
        })
    }

source

pub fn path(&mut self, value: &'a str) -> &mut Self

Set the request path.

Examples found in repository ?

src/response_builder.rs (line 48)

    pub fn request_uri(&mut self, uri: &'a Uri) -> &mut Self {
        self.path(uri.path());
        self.query(uri.query());
        self
    }

source

pub fn query(&mut self, value: Option<&'a str>) -> &mut Self

Set the request query string.

Examples found in repository ?

src/response_builder.rs (line 49)

    pub fn request_uri(&mut self, uri: &'a Uri) -> &mut Self {
        self.path(uri.path());
        self.query(uri.query());
        self
    }

source

pub fn build(&self, result: ResolveResult) -> Result<Response<Body>>

Build a response for the given request and resolve result.

This function may error if it response could not be constructed, but this should be a seldom occurrence.

Examples found in repository ?

src/service.rs (line 60)

    pub async fn serve<B>(self, request: Request<B>) -> Result<Response<Body>, IoError> {
        let Self {
            root,
            cache_headers,
        } = self;
        resolve(root, &request).await.map(|result| {
            ResponseBuilder::new()
                .request(&request)
                .cache_headers(cache_headers)
                .build(result)
                .expect("unable to build response")
        })
    }