Struct ResourceFiles 

pub struct ResourceFiles<C = HashMap<&'static str, Resource>> { /* private fields */ }

Static resource files handling

ResourceFiles service must be registered with App::service method.

use std::collections::HashMap;

use actix_web::App;

fn main() {
    // serve root directory with default options:
    // - resolve index.html
    let files: HashMap<&'static str, static_files::Resource> = HashMap::new();
    let app = App::new()
        .service(actix_web_static_files::ResourceFiles::new("/", files));
    // or subpath with additional option to not resolve index.html
    let files: HashMap<&'static str, static_files::Resource> = HashMap::new();
    let app = App::new()
        .service(actix_web_static_files::ResourceFiles::new("/imgs", files)
            .do_not_resolve_defaults());
}

Implementations

impl<F> ResourceFiles<F>

where F: ResourceFilesCollection + 'static,

pub fn new(path: &str, files: F) -> Self

pub fn do_not_resolve_defaults(self) -> Self

By default trying to resolve ‘…/’ to ‘…/index.html’ if it exists. Turn off this resolution by calling this function.

pub fn resolve_not_found_to<S: ToString>(self, path: S) -> Self

Resolves not found references to this path.

This can be useful for angular-like applications.

pub fn resolve_not_found_to_root(self) -> Self

Resolves not found references to root path.

This can be useful for angular-like applications.

pub fn skip_handler_when_not_found(self) -> Self

If this is called, we will use a Guard to check if this request should be handled. If set to true, we skip using the handler for files that haven’t been found, instead of sending 404s. Would be ignored, if resolve_not_found_to or resolve_not_found_to_root is used.

Can be useful if you want to share files on a (sub)path that’s also used by a different route handler.

Trait Implementations

impl<C> Deref for ResourceFiles<C>

type Target = ResourceFilesInner<C>

The resulting type after dereferencing.

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

Dereferences the value.

impl<C> HttpServiceFactory for ResourceFiles<C>

where C: ResourceFilesCollection + 'static,

fn register(self, config: &mut AppService)

impl<C> ServiceFactory<ServiceRequest> for ResourceFiles<C>

where C: ResourceFilesCollection + 'static,

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ResourceFilesService<C>

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Pin<Box<dyn Future<Output = Result<<ResourceFiles<C> as ServiceFactory<ServiceRequest>>::Service, <ResourceFiles<C> as ServiceFactory<ServiceRequest>>::InitError>>>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.