Trait cursive_core::builder::Resolvable

pub trait Resolvable {
    // Provided methods
    fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>
       where Self: Sized { ... }
    fn from_any(any: Box<dyn Any>) -> Option<Self>
       where Self: Sized + Any { ... }
}

Trait for types that can be resolved from a context.

They can be loaded from a config (yaml), or from a stored value (Box<Any>).

Provided Methods

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

where Self: Sized,

Build from a config (a JSON value).

The default implementation always fails.

fn from_any(any: Box<dyn Any>) -> Option<Self>

where Self: Sized + Any,

Build from an Any variable.

Default implementation tries to downcast to Self.

Override if you want to try downcasting to other types as well.

Implementations on Foreign Types

impl Resolvable for bool

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for f32

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for f64

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for i8

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for i16

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for i32

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for i64

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for i128

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for isize

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for u8

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for u16

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for u32

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for u64

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for u128

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for usize

fn from_any(any: Box<dyn Any>) -> Option<Self>

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

impl Resolvable for Box<dyn View>

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

impl Resolvable for String

fn from_config(config: &Config, _context: &Context) -> Result<Self, Error>

fn from_any(any: Box<dyn Any>) -> Option<Self>

where Self: Sized + Any,

impl<A, B> Resolvable for (A, B)

where A: Resolvable + 'static, B: Resolvable + 'static,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

where Self: Sized,

impl<A, B, C> Resolvable for (A, B, C)

where A: Resolvable + 'static, B: Resolvable + 'static, C: Resolvable + 'static,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

where Self: Sized,

impl<Res, A> Resolvable for Arc<dyn Fn(A) -> Res + Send + Sync>

impl<Res, A, B> Resolvable for Arc<dyn Fn(A, B) -> Res + Send + Sync>

impl<Res, A, B, C> Resolvable for Arc<dyn Fn(A, B, C) -> Res + Send + Sync>

impl<Res, A, B, C, D> Resolvable for Arc<dyn Fn(A, B, C, D) -> Res + Send + Sync>

impl<Res, A, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, C, &D) -> Res + Send + Sync>

impl<Res, A, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, C, &mut D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized> Resolvable for Arc<dyn Fn(A, B, &C) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized> Resolvable for Arc<dyn Fn(A, B, &mut C) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, B, &C, D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, B, &mut C, D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, &C, &D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized> Resolvable for Arc<dyn Fn(A, &B) -> Res + Send + Sync>

impl<Res, A, B: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C> Resolvable for Arc<dyn Fn(A, &B, C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C> Resolvable for Arc<dyn Fn(A, &mut B, C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(A, &B, C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(A, &mut B, C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &mut C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &mut C) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, &B, &C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, &B, &mut C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, &mut B, &C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(A, &mut B, &mut C, D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(A, &mut B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized> Resolvable for Arc<dyn Fn(&A) -> Res + Send + Sync>

impl<Res, A: ?Sized> Resolvable for Arc<dyn Fn(&mut A) -> Res + Send + Sync>

impl<Res, A: ?Sized, B> Resolvable for Arc<dyn Fn(&A, B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B> Resolvable for Arc<dyn Fn(&mut A, B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C> Resolvable for Arc<dyn Fn(&A, B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C> Resolvable for Arc<dyn Fn(&mut A, B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D> Resolvable for Arc<dyn Fn(&A, B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D> Resolvable for Arc<dyn Fn(&mut A, B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized> Resolvable for Arc<dyn Fn(&A, &B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C> Resolvable for Arc<dyn Fn(&A, &B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C> Resolvable for Arc<dyn Fn(&A, &mut B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C> Resolvable for Arc<dyn Fn(&mut A, &B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C> Resolvable for Arc<dyn Fn(&mut A, &mut B, C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(&A, &B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(&A, &mut B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(&mut A, &B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D> Resolvable for Arc<dyn Fn(&mut A, &mut B, C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &mut C) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, &B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, &B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, &mut B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&A, &mut B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, &B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, &B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, &mut B, &C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D> Resolvable for Arc<dyn Fn(&mut A, &mut B, &mut C, D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&A, &mut B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &B, &mut C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &C, &mut D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &mut C, &D) -> Res + Send + Sync>

impl<Res, A: ?Sized, B: ?Sized, C: ?Sized, D: ?Sized> Resolvable for Arc<dyn Fn(&mut A, &mut B, &mut C, &mut D) -> Res + Send + Sync>

impl<T> Resolvable for Option<T>

where T: Resolvable,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

fn from_any(any: Box<dyn Any>) -> Option<Self>

where Self: Sized + Any,

impl<T> Resolvable for Box<T>

where T: 'static + Resolvable,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

fn from_any(any: Box<dyn Any>) -> Option<Self>

impl<T> Resolvable for Arc<T>

where T: 'static + Resolvable,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

fn from_any(any: Box<dyn Any>) -> Option<Self>

impl<T> Resolvable for Vec<T>

where T: 'static + Resolvable,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

impl<T> Resolvable for HashMap<String, T>

where T: 'static + Resolvable,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

impl<T, const N: usize> Resolvable for [T; N]

where T: 'static + Resolvable + Clone,

fn from_any(any: Box<dyn Any>) -> Option<Self>

where Self: Sized + Any,

fn from_config(config: &Config, context: &Context) -> Result<Self, Error>

Implementors

impl Resolvable for HAlign

impl Resolvable for VAlign

impl Resolvable for Absolute

impl Resolvable for Direction

impl Resolvable for Orientation

impl Resolvable for Relative

impl Resolvable for BaseColor

impl Resolvable for BorderStyle

impl Resolvable for Color

impl Resolvable for ColorType

impl Resolvable for Effect

impl Resolvable for PaletteColor

impl Resolvable for Offset

impl Resolvable for SizeConstraint

impl Resolvable for ScrollStrategy

impl Resolvable for DialogFocus

impl Resolvable for ListChild

impl Resolvable for LayerPosition

impl Resolvable for Align

impl Resolvable for Rect

impl Resolvable for Angled

impl Resolvable for Bilinear

impl Resolvable for Linear

impl Resolvable for Radial

impl Resolvable for ColorPair

impl Resolvable for ColorStyle

impl Resolvable for Palette

impl Resolvable for Rgb<f32>

impl Resolvable for Rgb<u8>

impl Resolvable for Theme

impl Resolvable for Margins

impl Resolvable for BoxedView

impl Resolvable for RadioGroup<String>

impl Resolvable for Dynterpolator

impl Resolvable for StyledString

impl Resolvable for Config

impl Resolvable for Object

impl<T> Resolvable for NoConfig<T>

impl<T: Resolvable + 'static> Resolvable for XY<T>