Struct rocket_lang::Config

pub struct Config {
    pub wildcard: Option<LangCode>,
    /* private fields */
}

This struct allows for customization of LangCode’s behavior. The precedence for every configuration is:

1. custom closure
2. from url
3. accept language header
4. wildcard

If none of these are able to produce an Ok value, an error is returned. Note that returning errors is discouraged, as it may lead to a poor user experience.

Custom closure

This configuration has the biggest precedence. There is full access to the incoming request.

let config = Config::new().custom(|request: &Request| {
    Ok(lang_from_request(request))
});

Url

The url method can be used to specify which segment should be interpreted as a language code. Negative indexes can be used to refer to positions relative to the last segment. Thus -1 corresponds to the last segment, -2 the second to last, and so on.

examples

// we use -1 to specify that the last segment is our language code
let config = Config::new().url(-1);
// we have to specify which language we want on the handler
#[get("/index/en")
fn english_language() {
   /* ... */
}
// we can handle all languages at once with a wildcard segment.
// if we visit with an invalid language code ("/index/not-a-lang-code/"), an error is returned.
#[get("/index/<_>", rank = 2)
fn any_language() {
   /* ... */
}

Accept Language

The accept language header qualities can be set by indexing into the config struct. By default, all values are set to 0.0. These values should correspond to a number between 0.0 and 1.0 specifying the quality of that language support of your site.

let config = Config::new();
config[En] = 0.3;
config[Ar] = 1.0;

Wildcard

The wildcard will be used to create a value if none of the previous attempts succeeded. Note that wildcards are useful for single language applications, but they may not scale as well as url resolution. By default the wildcard is set to None.

let config = Config::new().url(1).wildcard(Es);

Fields

wildcard: Option<LangCode>

Implementations

impl Config

pub fn wildcard(self, lang: LangCode) -> Self

The wildcard is used as a last resort if all other options failed.

pub fn url(self, position: i32) -> Self

Takes the Config structure by value and returns a new one with the url configuration set. The position parameter determines which path segment will be interpreted as a language code. Negative positions will be interpreted as being relative to the last path segment.

pub fn new() -> Self

Constructs a new configuration object.

pub fn custom<F>(self, f: F) -> Self where
    F: Fn(&Request<'_>) -> Result<LangCode, Error> + 'static + Send + Sync, 

Used to specify a custom language resolution method.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl Fairing for Config

fn info(&self) -> Info

Returns an Info structure containing the name and Kind of this fairing. The name can be any arbitrary string. Kind must be an ord set of Kind variants.

fn on_ignite<'life0, 'async_trait>(
    &'life0 self,
    rocket: Rocket<Build>
) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The ignite callback. Returns Ok if ignition should proceed and Err if ignition and launch should be aborted.

fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request<'life2>,
    _data: &'life3 mut Data<'life4>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

The request callback.

fn on_liftoff<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _rocket: &'life1 Rocket<Orbit>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

The liftoff callback.

fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    _req: &'r Request<'life1>,
    _res: &'life2 mut Response<'r>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

The response callback.

impl Index<LangCode> for Config

type Output = f32

The returned type after indexing.

fn index(&self, index: LangCode) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<LangCode> for Config

fn index_mut(&mut self, index: LangCode) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.