Struct CfgPathResolver 

pub struct CfgPathResolver { /* private fields */ }

A variable resolver for paths in a configuration file.

Typically there should be one resolver per application, and the application should share the resolver throughout the application to have consistent path variable expansions. Typically the application would create its own resolver with its application-specific variables, but note that TorClientConfig is an exception which does not accept a resolver from the application and instead generates its own. This is done for backwards compatibility reasons.

Once constructed, they are used during calls to CfgPath::path to expand variables in the path.

Implementations

impl CfgPathResolver

pub fn set_var( &mut self, var: impl Into<String>, val: Result<Cow<'static, Path>, CfgPathError>, )

Set a variable var that will be replaced with val when a CfgPath is expanded.

Setting an Err is useful when a variable is supported, but for whatever reason it can’t be expanded, and you’d like to return a more-specific error. An example might be a USER_HOME variable for a user that doesn’t have a HOME environment variable set.

use std::path::Path;
use tor_config_path::{CfgPath, CfgPathResolver};

let mut path_resolver = CfgPathResolver::default();
path_resolver.set_var("FOO", Ok(Path::new("/foo").to_owned().into()));

let path = CfgPath::new("${FOO}/bar".into());

#[cfg(feature = "expand-paths")]
assert_eq!(path.path(&path_resolver).unwrap(), Path::new("/foo/bar"));
#[cfg(not(feature = "expand-paths"))]
assert!(path.path(&path_resolver).is_err());

Trait Implementations

impl Clone for CfgPathResolver

fn clone(&self) -> CfgPathResolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CfgPathResolver

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

Formats the value using the given formatter.

impl Default for CfgPathResolver

fn default() -> CfgPathResolver

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes