[−][src]Struct zebrad::application::ZebradApp

pub struct ZebradApp {
    config: Option<ZebradConfig>,
    state: State<Self>,
}

Zebrad Application

Fields

config: Option<ZebradConfig>

Application configuration.

state: State<Self>

Application state.

Trait Implementations

`impl Application for ZebradApp`[src]

`type Cmd = EntryPoint<ZebradCmd>`

Entrypoint command for this application.

`type Cfg = ZebradConfig`

Application configuration.

`type Paths = StandardPaths`

Paths to resources within the application.

`fn config(&self) -> &ZebradConfig`[src]

Accessor for application configuration.

`fn state(&self) -> &State<Self>`[src]

Borrow the application state immutably.

`fn state_mut(&mut self) -> &mut State<Self>`[src]

Borrow the application state mutably.

`fn framework_components( &mut self, command: &Self::Cmd ) -> Result<Vec<Box<dyn Component<Self>>>, FrameworkError>`[src]

Returns the framework components used by this application.

`fn register_components( &mut self, command: &Self::Cmd ) -> Result<(), FrameworkError>`[src]

Register all components used by this application.

If you would like to add additional components to your application beyond the default ones provided by the framework, this is the place to do so.

`fn init(&mut self, command: &Self::Cmd) -> Result<(), FrameworkError>`[src]

Load this application's configuration and initialize its components.

`fn after_config(&mut self, config: Self::Cfg) -> Result<(), FrameworkError>`[src]

Post-configuration lifecycle callback.

Called regardless of whether config is loaded to indicate this is the time in app lifecycle when configuration would be loaded if possible.

`fn shutdown(&mut self, shutdown: Shutdown) -> !`[src]

`fn run(app_cell: &'static Cell<Lock<Self>>, args: I) where I: IntoIterator<Item = String>,` [src]

`fn load_config(&mut self, path: &Path) -> Result<Self::Cfg, FrameworkError>`[src]

`fn name(&self) -> &'static str`[src]

`fn description(&self) -> &'static str`[src]

`fn version(&self) -> Version`[src]

`fn authors(&self) -> Vec<String>`[src]

`fn term_colors(&self, command: &Self::Cmd) -> ColorChoice`[src]

`fn tracing_config(&self, command: &Self::Cmd) -> Config`[src]

`fn handle_signal(&mut self, signal: Signal) -> Result<(), FrameworkError>`[src]

`impl Debug for ZebradApp`[src]

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

`impl Default for ZebradApp`[src]

Initialize a new application instance.

By default no configuration is loaded, and the framework state is initialized to a default, empty state (no components, threads, etc).

`fn default() -> Self`[src]

Auto Trait Implementations

`impl !RefUnwindSafe for ZebradApp`

`impl Send for ZebradApp`

`impl Sync for ZebradApp`

`impl Unpin for ZebradApp`

`impl !UnwindSafe for ZebradApp`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> AsAny for T where T: Any,` [src]

`fn as_any(&self) -> &(dyn Any + 'static)`[src]

`fn as_mut_any(&mut self) -> &mut (dyn Any + 'static)`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Erased for T`

`impl<T> FmtForward for T`

`fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T> Instrument for T`[src]

`fn instrument(self, span: Span) -> Instrumented<Self>`[src]

`fn in_current_span(self) -> Instrumented<Self>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<D> OwoColorize for D`

`fn fg<C>(&'a self) -> FgColorDisplay<'a, C, Self> where C: Color,`

`fn bg<C>(&'a self) -> BgColorDisplay<'a, C, Self> where C: Color,`

`fn black(&'a self) -> FgColorDisplay<'a, Black, Self>`

`fn on_black(&'a self) -> BgColorDisplay<'a, Black, Self>`

`fn red(&'a self) -> FgColorDisplay<'a, Red, Self>`

`fn on_red(&'a self) -> BgColorDisplay<'a, Red, Self>`

`fn green(&'a self) -> FgColorDisplay<'a, Green, Self>`

`fn on_green(&'a self) -> BgColorDisplay<'a, Green, Self>`

`fn yellow(&'a self) -> FgColorDisplay<'a, Yellow, Self>`

`fn on_yellow(&'a self) -> BgColorDisplay<'a, Yellow, Self>`

`fn blue(&'a self) -> FgColorDisplay<'a, Blue, Self>`

`fn on_blue(&'a self) -> BgColorDisplay<'a, Blue, Self>`

`fn magenta(&'a self) -> FgColorDisplay<'a, Magenta, Self>`

`fn on_magenta(&'a self) -> BgColorDisplay<'a, Magenta, Self>`

`fn purple(&'a self) -> FgColorDisplay<'a, Magenta, Self>`

`fn on_purple(&'a self) -> BgColorDisplay<'a, Magenta, Self>`

`fn cyan(&'a self) -> FgColorDisplay<'a, Cyan, Self>`

`fn on_cyan(&'a self) -> BgColorDisplay<'a, Cyan, Self>`

`fn white(&'a self) -> FgColorDisplay<'a, White, Self>`

`fn on_white(&'a self) -> BgColorDisplay<'a, White, Self>`

`fn bright_black(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>`

`fn on_bright_black(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>`

`fn bright_red(&'a self) -> FgColorDisplay<'a, BrightRed, Self>`

`fn on_bright_red(&'a self) -> BgColorDisplay<'a, BrightRed, Self>`

`fn bright_green(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>`

`fn on_bright_green(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>`

`fn bright_yellow(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>`

`fn on_bright_yellow(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>`

`fn bright_blue(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>`

`fn on_bright_blue(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>`

`fn bright_magenta(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>`

`fn on_bright_magenta(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>`

`fn bright_purple(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>`

`fn on_bright_purple(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>`

`fn bright_cyan(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>`

`fn on_bright_cyan(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>`

`fn bright_white(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>`

`fn on_bright_white(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>`

`fn bold(&'a self) -> BoldDisplay<'a, Self>`

`fn dimmed(&'a self) -> DimDisplay<'a, Self>`

`fn italic(&'a self) -> ItalicDisplay<'a, Self>`

`fn underline(&'a self) -> UnderlineDisplay<'a, Self>`

`fn blink(&'a self) -> BlinkDisplay<'a, Self>`

`fn blink_fast(&'a self) -> BlinkFastDisplay<'a, Self>`

`fn reversed(&'a self) -> ReversedDisplay<'a, Self>`

`fn hidden(&'a self) -> HiddenDisplay<'a, Self>`

`fn strikethrough(&'a self) -> StrikeThroughDisplay<'a, Self>`

`fn color<Color>(&'a self, color: Color) -> FgDynColorDisplay<'a, Color, Self> where Color: DynColor,`

`fn on_color<Color>(&'a self, color: Color) -> BgDynColorDisplay<'a, Color, Self> where Color: DynColor,`

`fn truecolor(&'a self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'a, Rgb, Self>`

`fn on_truecolor( &'a self, r: u8, g: u8, b: u8 ) -> BgDynColorDisplay<'a, Rgb, Self>`

`impl<T> Pipe for T`

`fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: AsRef<T>, T: 'a,`

`fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where R: 'a, Self: AsMut<T>, T: 'a,`

`impl<T> PipeBorrow for T`

`fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Borrow<T>, T: 'a,`

`fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: BorrowMut<T>, T: 'a,`

`impl<T> PipeDeref for T`

`fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where R: 'a, Self: Deref,`

`fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where R: 'a, Self: DerefMut,`

`impl<T> PipeRef for T`

`fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> Tap for T`

`fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`fn tap_ref<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`fn tap_ref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`fn tap_ref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`fn tap_borrow<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`fn tap_borrow_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`fn tap_borrow_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`impl<T> TapDeref for T`

`fn tap_deref<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`fn tap_deref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`fn tap_deref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`impl<T> TryConv for T`

`fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`fn vzip(self) -> V`

`impl<T> WithSubscriber for T`[src]

`fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,` [src]

`fn with_current_subscriber(self) -> WithDispatch<Self>`[src]

[−][src]Struct zebrad::application::ZebradApp

Fields

Trait Implementations

impl Application for ZebradApp[src]

type Cmd = EntryPoint<ZebradCmd>

type Cfg = ZebradConfig

type Paths = StandardPaths

fn config(&self) -> &ZebradConfig[src]

fn state(&self) -> &State<Self>[src]

fn state_mut(&mut self) -> &mut State<Self>[src]

fn framework_components( &mut self, command: &Self::Cmd) -> Result<Vec<Box<dyn Component<Self>>>, FrameworkError>[src]

fn register_components( &mut self, command: &Self::Cmd) -> Result<(), FrameworkError>[src]

fn init(&mut self, command: &Self::Cmd) -> Result<(), FrameworkError>[src]

fn after_config(&mut self, config: Self::Cfg) -> Result<(), FrameworkError>[src]

fn shutdown(&mut self, shutdown: Shutdown) -> ![src]

fn run<I>(app_cell: &'static Cell<Lock<Self>>, args: I) where I: IntoIterator<Item = String>, [src]

fn load_config(&mut self, path: &Path) -> Result<Self::Cfg, FrameworkError>[src]

fn name(&self) -> &'static str[src]

fn description(&self) -> &'static str[src]

fn version(&self) -> Version[src]

fn authors(&self) -> Vec<String>[src]

fn term_colors(&self, command: &Self::Cmd) -> ColorChoice[src]

fn tracing_config(&self, command: &Self::Cmd) -> Config[src]

fn handle_signal(&mut self, signal: Signal) -> Result<(), FrameworkError>[src]

impl Debug for ZebradApp[src]

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

impl Default for ZebradApp[src]

fn default() -> Self[src]

Auto Trait Implementations

impl !RefUnwindSafe for ZebradApp

impl Send for ZebradApp

impl Sync for ZebradApp

impl Unpin for ZebradApp

impl !UnwindSafe for ZebradApp

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> AsAny for T where T: Any, [src]

fn as_any(&self) -> &(dyn Any + 'static)[src]

fn as_mut_any(&mut self) -> &mut (dyn Any + 'static)[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Erased for T

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

fn in_current_span(self) -> Instrumented<Self>[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<D> OwoColorize for D

fn fg<C>(&'a self) -> FgColorDisplay<'a, C, Self> where C: Color,

fn bg<C>(&'a self) -> BgColorDisplay<'a, C, Self> where C: Color,

fn black(&'a self) -> FgColorDisplay<'a, Black, Self>

fn on_black(&'a self) -> BgColorDisplay<'a, Black, Self>

fn red(&'a self) -> FgColorDisplay<'a, Red, Self>

fn on_red(&'a self) -> BgColorDisplay<'a, Red, Self>

fn green(&'a self) -> FgColorDisplay<'a, Green, Self>

fn on_green(&'a self) -> BgColorDisplay<'a, Green, Self>

fn yellow(&'a self) -> FgColorDisplay<'a, Yellow, Self>

fn on_yellow(&'a self) -> BgColorDisplay<'a, Yellow, Self>

fn blue(&'a self) -> FgColorDisplay<'a, Blue, Self>

fn on_blue(&'a self) -> BgColorDisplay<'a, Blue, Self>

fn magenta(&'a self) -> FgColorDisplay<'a, Magenta, Self>

fn on_magenta(&'a self) -> BgColorDisplay<'a, Magenta, Self>

fn purple(&'a self) -> FgColorDisplay<'a, Magenta, Self>

fn on_purple(&'a self) -> BgColorDisplay<'a, Magenta, Self>