Enum Environment

pub enum Environment {
    Development,
    Staging,
    Production,
}

An enum corresponding to the valid configuration environments.

Variants

Development

The development environment.

Staging

The staging environment.

Production

The production environment.

Implementations

impl Environment

pub fn active() -> Result<Environment, ConfigError>

Retrieves the “active” environment as determined by the ROCKET_ENV environment variable. If ROCKET_ENV is not set, returns Development when the application was compiled in debug mode and Production when the application was compiled in release mode.

Errors

Returns a BadEnv ConfigError if ROCKET_ENV is set and contains an invalid or unknown environment name.

pub fn is_dev(self) -> bool

Returns true if self is Environment::Development.

Example

use rocket::config::Environment;

assert!(Environment::Development.is_dev());
assert!(!Environment::Production.is_dev());

pub fn is_stage(self) -> bool

Returns true if self is Environment::Staging.

Example

use rocket::config::Environment;

assert!(Environment::Staging.is_stage());
assert!(!Environment::Production.is_stage());

pub fn is_prod(self) -> bool

Returns true if self is Environment::Production.

Example

use rocket::config::Environment;

assert!(Environment::Production.is_prod());
assert!(!Environment::Staging.is_prod());

Trait Implementations

impl Clone for Environment

fn clone(&self) -> Environment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Environment

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

Formats the value using the given formatter.

impl Display for Environment

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

Formats the value using the given formatter.

impl FromStr for Environment

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a configuration environment from a string. Should be used indirectly via str’s parse method.

Examples

Parsing a development environment:

use rocket::config::Environment;

let env = "development".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Development);

let env = "dev".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Development);

let env = "devel".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Development);

Parsing a staging environment:

use rocket::config::Environment;

let env = "staging".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Staging);

let env = "stage".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Staging);

Parsing a production environment:

use rocket::config::Environment;

let env = "production".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Production);

let env = "prod".parse::<Environment>();
assert_eq!(env.unwrap(), Environment::Production);

type Err = ()

The associated error which can be returned from parsing.

impl Hash for Environment

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Environment

fn eq(&self, other: &Environment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Environment

impl Eq for Environment

impl StructuralPartialEq for Environment