Struct figment::Profile

pub struct Profile(/* private fields */);

A configuration profile: effectively a case-insensitive string.

See the top-level docs for details.

Implementations

impl Profile

pub const Default: Profile = _

The default profile: "default".

pub const Global: Profile = _

The global profile: "global".

pub fn new(name: &str) -> Profile

Constructs a profile with the name name.

Example

use figment::Profile;

let profile = Profile::new("staging");
assert_eq!(profile, "staging");
assert_eq!(profile, "STAGING");

pub const fn const_new(name: &'static str) -> Profile

A const to construct a profile with the name name.

Example

use figment::Profile;

const STAGING: Profile = Profile::const_new("staging");

assert_eq!(STAGING, "staging");
assert_eq!(STAGING, "STAGING");

pub fn from_env(key: &str) -> Option<Self>

Constructs a profile from the value of the environment variable with name key, if one is present. The search for key is case-insensitive.

Example

use figment::{Profile, Jail};

Jail::expect_with(|jail| {
    jail.set_env("MY_PROFILE", "secret");

    assert_eq!(Profile::from_env("MY_PROFILE"), Some("secret".into()));
    assert_eq!(Profile::from_env("MY_PROFILE"), Some("secret".into()));
    assert_eq!(Profile::from_env("MY_profile"), Some("secret".into()));
    assert_eq!(Profile::from_env("other_profile"), None);
    Ok(())
});

pub fn from_env_or<P: Into<Profile>>(var: &str, default: P) -> Self

Constructs a profile from the value of the environment variable with name var, if one is present, or default if one is not. The search for var is case-insensitive.

Example

use figment::{Profile, Jail};

Jail::expect_with(|jail| {
    jail.set_env("MY_PROFILE", "secret");

    assert_eq!(Profile::from_env_or("MY_PROFILE", "default"), "secret");
    assert_eq!(Profile::from_env_or("MY_profile", "default"), "secret");
    assert_eq!(Profile::from_env_or("other_prof", "default"), "default");
    Ok(())
});

pub fn as_str(&self) -> &UncasedStr

Converts self into an &UncasedStr.

Example

use figment::Profile;

let profile = Profile::new("static");
let string = profile.as_str();

pub fn starts_with(&self, prefix: &str) -> bool

Returns true iff self case-insensitively starts with prefix.

Example

use figment::Profile;

let profile = Profile::new("static");
assert!(profile.starts_with("STAT"));
assert!(profile.starts_with("stat"));
assert!(profile.starts_with("static"));

pub fn is_custom(&self) -> bool

Returns true iff self is neither “default” nor “global”.

Example

use figment::Profile;

let profile = Profile::new("static");
assert!(profile.is_custom());

assert!(!Profile::Default.is_custom());
assert!(!Profile::Global.is_custom());

pub fn collect(&self, dict: Dict) -> Map<Profile, Dict>

Creates a new map with a single key of *self and a value of dict.

Example

use figment::{Profile, util::map};

let profile = Profile::new("static");
let map = profile.collect(map!["hi".into() => 123.into()]);

Methods from Deref<Target = UncasedStr>

pub fn as_str(&self) -> &str

Returns self as an &str.

Example

use uncased::UncasedStr;

let uncased_str = UncasedStr::new("Hello!");
assert_eq!(uncased_str.as_str(), "Hello!");
assert_ne!(uncased_str.as_str(), "hELLo!");

pub fn len(&self) -> usize

Returns the length, in bytes, of self.

Example

use uncased::UncasedStr;

let uncased_str = UncasedStr::new("Hello!");
assert_eq!(uncased_str.len(), 6);

pub fn is_empty(&self) -> bool

Returns true if self has a length of zero bytes.

Examples

use uncased::UncasedStr;

let s = UncasedStr::new("");
assert!(s.is_empty());

let s = UncasedStr::new("not empty");
assert!(!s.is_empty());

pub fn starts_with(&self, string: &str) -> bool

Returns true if self starts with any casing of the string string; otherwise, returns false.

Example

use uncased::UncasedStr;

let uncased_str = UncasedStr::new("MoOO");
assert!(uncased_str.starts_with("moo"));
assert!(uncased_str.starts_with("MOO"));
assert!(uncased_str.starts_with("MOOO"));
assert!(!uncased_str.starts_with("boo"));

let uncased_str = UncasedStr::new("Bèe");
assert!(!uncased_str.starts_with("Be"));
assert!(uncased_str.starts_with("Bè"));
assert!(uncased_str.starts_with("Bè"));
assert!(uncased_str.starts_with("bèe"));
assert!(uncased_str.starts_with("BèE"));

Trait Implementations

impl Clone for Profile

fn clone(&self) -> Profile

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Profile

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

Formats the value using the given formatter.

impl Default for Profile

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Profile

type Target = UncasedStr

The resulting type after dereferencing.

fn deref(&self) -> &UncasedStr

Dereferences the value.

impl<'de> Deserialize<'de> for Profile

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Profile

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

Formats the value using the given formatter.

impl From<Profile> for String

fn from(profile: Profile) -> String

Converts to this type from the input type.

impl<T: AsRef<str>> From<T> for Profile

fn from(string: T) -> Profile

Converts to this type from the input type.

impl Hash for Profile

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 Ord for Profile

fn cmp(&self, other: &Profile) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<&Profile> for Profile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&str> for Profile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Profile> for &Profile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Profile> for &str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Profile> for Profile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Profile> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<str> for Profile

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Profile> for Profile

fn partial_cmp(&self, other: &Profile) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Profile

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Profile

impl StructuralEq for Profile

impl StructuralPartialEq for Profile