Struct rocket_dyn_templates::Metadata

pub struct Metadata<'a>(_);

Request guard for dynamically querying template metadata.

Usage

The Metadata type implements Rocket’s FromRequest trait, so it can be used as a request guard in any request handler.

use rocket_dyn_templates::{Template, Metadata, context};

#[get("/")]
fn homepage(metadata: Metadata) -> Template {
    // Conditionally render a template if it's available.
    if metadata.contains_template("some-template") {
        Template::render("some-template", &context)
    } else {
        Template::render("fallback", &context)
    }
}

fn main() {
    rocket::build()
        .attach(Template::fairing())
        // ...
}

Implementations

impl Metadata<'_>

pub fn contains_template(&self, name: &str) -> bool

Returns true if the template with the given name is currently loaded. Otherwise, returns false.

Example

use rocket_dyn_templates::Metadata;

#[get("/")]
fn handler(metadata: Metadata) {
    // Returns `true` if the template with name `"name"` was loaded.
    let loaded = metadata.contains_template("name");
}

pub fn reloading(&self) -> bool

Returns true if template reloading is enabled.

Example

use rocket_dyn_templates::Metadata;

#[get("/")]
fn handler(metadata: Metadata) {
    // Returns `true` if template reloading is enabled.
    let reloading = metadata.reloading();
}

pub fn render<S, C>(&self, name: S, context: C) -> Option<(ContentType, String)> where
    S: Into<Cow<'static, str>>,
    C: Serialize, 

Directly render the template named name with the context context into a String. Also returns the template’s detected ContentType. See Template::render() for more details on rendering.

Examples

use rocket::http::ContentType;
use rocket_dyn_templates::{Metadata, Template, context};

#[get("/")]
fn send_email(metadata: Metadata) -> Option<()> {
    let (mime, string) = metadata.render("email", context! {
        field: "Hello, world!"
    })?;

    send_email(mime, string).await?;
    Some(())
}

#[get("/")]
fn raw_render(metadata: Metadata) -> Option<(ContentType, String)> {
    metadata.render("index", context! { field: "Hello, world!" })
}

// Prefer the following, however, which is nearly identical but pithier:

#[get("/")]
fn render() -> Template {
    Template::render("index", context! { field: "Hello, world!" })
}

Trait Implementations

impl<'r> FromRequest<'r> for Metadata<'r>

Retrieves the template metadata. If a template fairing hasn’t been attached, an error is printed and an empty Err with status InternalServerError (500) is returned.

type Error = ()

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>(
    request: &'r Request<'life0>
) -> Pin<Box<dyn Future<Output = Outcome<Self, ()>> + Send + 'async_trait>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Derives an instance of Self from the incoming request metadata.

impl Sentinel for Metadata<'_>

fn abort(rocket: &Rocket<Ignite>) -> bool

Returns true if launch should be aborted and false otherwise.