Struct spirit::Builder

#[must_use = "The builder is inactive without calling `run` or `build`"]pub struct Builder<O = Empty, C = Empty> { /* fields omitted */ }

The builder of Spirit.

This is returned by the Spirit::new.

Interface

Most of the methods are available through the following traits. You want to bring them into scope (possibly by use spirit::prelude::*) and look at their methods.

• ConfigBuilder to specify how configuration should be loaded.
• Extensible to register callbacks.
• SpiritBuilder to turn the builder into Spirit.

Implementations

impl<O, C> Builder<O, C> where
    C: DeserializeOwned + Send + Sync + 'static,
    O: StructOpt + Sync + Send + 'static, 

pub fn config_loader(self, loader: CfgBuilder) -> Self

Sets the inner config loader.

Instead of configuring the configuration loading on the spirit Builder, the inner config loader Builder can be set directly.

Trait Implementations

impl<O, C> ConfigBuilder for Builder<O, C>

fn config_default_paths<P, I>(self, paths: I) -> Self where
    I: IntoIterator<Item = P>,
    P: Into<PathBuf>, 

Sets the configuration paths in case the user doesn't provide any.

fn config_defaults<D: Into<String>>(self, config: D) -> Self

Specifies the default configuration.

fn config_env<E: Into<String>>(self, env: E) -> Self

Enables loading configuration from environment variables.

fn config_filter<F: FnMut(&Path) -> bool + Send + 'static>(
    self,
    filter: F
) -> Self

Sets a configuration dir filter.

fn warn_on_unused(self, warn: bool) -> Self

Sets if warning should be produced for each unused configuration key.

fn config_defaults_typed<C: Serialize>(
    self,
    config: &C
) -> Result<Self, AnyError>

Specifies the default configuration as typed value.

fn config_ext<E: Into<OsString>>(self, ext: E) -> Self

Configures a config dir filter for a single extension.

fn config_exts<I, E>(self, exts: I) -> Self where
    I: IntoIterator<Item = E>,
    E: Into<OsString>, 

Configures a config dir filter for multiple extensions.

fn config_supported_exts(self) -> Self

Sets the config dir filter for all the supported extensions.

impl<O, C> Extensible for Builder<O, C>

type Opts = O

The command line options structure tied to this instance.

type Config = C

The configuration structure.

type Ok = Self

The Ok variant used when returning a result.

const STARTED: bool

Has the application already started?

fn before_config<F>(self, cback: F) -> Result<Self, AnyError> where
    F: FnOnce(&C, &O) -> Result<(), AnyError> + Send + 'static, 

A callback that is run after the building started and the command line is parsed, but even before the first configuration is loaded. The configuration provided is either the one provided to the builder, or a default one when called on the builder, but current configuration when run on Spirit.

fn config_validator<F>(self, f: F) -> Result<Self, AnyError> where
    F: FnMut(&Arc<C>, &Arc<C>, &O) -> Result<Action, AnyError> + Send + 'static, 

Adds another config validator to the chain.

fn config_mutator<F>(self, f: F) -> Self where
    F: FnMut(&mut C) + Send + 'static, 

Adds a callback able to mutate the configuration while being loaded.

fn on_config<F: FnMut(&O, &Arc<C>) + Send + 'static>(self, hook: F) -> Self

Adds a callback for notification about new configurations.

fn on_signal<F>(self, signal: c_int, hook: F) -> Result<Self, AnyError> where
    F: FnMut() + Send + 'static, 

Adds a callback for reacting to a signal.

fn on_terminate<F: FnOnce() + Send + 'static>(self, hook: F) -> Self

Adds a callback executed once the Spirit decides to terminate.

fn with<E>(self, ext: E) -> Result<Self::Ok, AnyError> where
    E: Extension<Self>, 

Apply an Extension.

fn singleton<T: 'static>(&mut self) -> bool

Check if this is the first call with the given type.

fn run_before<B>(self, body: B) -> Result<Self, AnyError> where
    B: FnOnce(&Arc<Spirit<O, C>>) -> Result<(), AnyError> + Send + 'static, 

Add a closure run before the main body.

fn run_around<W>(self, wrapper: W) -> Result<Self, AnyError> where
    W: FnOnce(&Arc<Spirit<O, C>>, Box<dyn FnOnce() -> Result<(), AnyError> + Send>) -> Result<(), AnyError> + Send + 'static, 

Wrap the body run by the run into this closure.

fn around_hooks<W>(self, wrapper: W) -> Self where
    W: HookWrapper, 

Wrap the hooks inside the provided closure.

fn with_singleton<T>(self, singleton: T) -> Result<Self, AnyError> where
    T: Extension<Self::Ok> + 'static, 

Applies the first Extension of the same type.

fn keep_guard<G: Any + Send>(self, guard: G) -> Self

Keeps a guard object until destruction.

fn autojoin_bg_thread(self, autojoin: Autojoin) -> Self

Specifies if and when the background thread should be joined automatically.

impl<O, C> SpiritBuilder for Builder<O, C> where
    Self::Config: DeserializeOwned + Send + Sync + 'static,
    Self::Opts: StructOpt + Sync + Send + 'static, 

fn build(self, background_thread: bool) -> Result<App<O, C>, AnyError>

Finish building the Spirit.

fn run<B: FnOnce(&Arc<Spirit<O, C>>) -> Result<(), AnyError> + Send + 'static>(
    self,
    body: B
)

Build the spirit and run the application, handling all relevant errors.