Enum EnvType

pub enum EnvType {
    Dev,
    Test,
    Stg,
    Prod,
    Custom(&'static str),
}

EnvType is an enum that represents the environment type. EnvType is derived from the strum crate, which provides the ability to convert the string to the enum.

Example

use env_type::types::EnvType;
use std::str::FromStr;

let env = EnvType::from_str("d").unwrap();
assert_eq!(EnvType::Dev, env);

let custom_env = EnvType::Custom("Custom");
assert_eq!(EnvType::Custom("Custom"), custom_env);

Variants

Dev

Test

Stg

Prod

Custom(&'static str)

Implementations

impl EnvType

pub const fn is_dev(&self) -> bool

Returns true if the enum is EnvType::Dev otherwise false

pub const fn is_test(&self) -> bool

Returns true if the enum is EnvType::Test otherwise false

pub const fn is_stg(&self) -> bool

Returns true if the enum is EnvType::Stg otherwise false

pub const fn is_prod(&self) -> bool

Returns true if the enum is EnvType::Prod otherwise false

pub const fn is_custom(&self) -> bool

Returns true if the enum is EnvType::Custom otherwise false

impl EnvType

pub fn from_env() -> Self

EnvType::from_env is a function that returns the environment type from the environment variable. This is deligated to from_env_key with EnvType as default from env key. The default environment type is Dev.

Example

use env_type::types::EnvType;
use std::str::FromStr;

std::env::set_var("ENV", "Production");
let env = EnvType::from_env();
assert_eq!(EnvType::Prod, env);

pub fn from_env_key<K: EnvKey>() -> Self

EnvType::from_env_key is a function that returns the environment type from the environment variable. The default environment type is Dev.

Example

use env_type::types::EnvType;
use std::str::FromStr;

std::env::set_var("ENV", "Test");
let env = EnvType::from_env_key::<EnvType>();
assert_eq!(EnvType::Test, env);

pub fn from_env_types<S: AsEnvStr, K: EnvKey>(s: S) -> Self

EnvType::from_env_types is a function that returns the EnvType from AsEnvStr and EnvKey.

pub fn from_env_str<T: AsEnvTypeStr>(t: T) -> Self

EnvType::from_env_str is a function that returns the environment type from the string. The default environment type is Dev.

Example

use env_type::types::{EnvType, AsEnvTypeStr};
use std::str::FromStr;

struct Config {
  env_str: String,
}
let config = Config {
 env_str: "Production".to_string(),
};

impl AsEnvTypeStr for Config {
  fn as_env_type_str(&self) -> Option<String> {
    Some(self.env_str.clone())
  }
}
let env = EnvType::from_env_str(config);
assert_eq!(EnvType::Prod, env);

Trait Implementations

impl AsEnvStr for EnvType

EnvType is an implementation of the AsEnvStr trait. EnvType is based on env var.

fn as_env_str<T: EnvKey>(&self) -> String

impl Clone for EnvType

fn clone(&self) -> EnvType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnvType

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

Formats the value using the given formatter.

impl Default for EnvType

fn default() -> EnvType

Returns the “default value” for a type.

impl EnvKey for EnvType

EnvType is an implementation of the EnvKey trait. The default environment key is “ENV”.

fn key() -> &'static str

impl FromStr for EnvType

type Err = ParseError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for EnvType

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 EnvType

fn eq(&self, other: &EnvType) -> 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 TryFrom<&str> for EnvType

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<EnvType, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Copy for EnvType

impl Eq for EnvType

impl StructuralPartialEq for EnvType