Trait patternfly_dioxus::UseFutureDep

pub trait UseFutureDep: Sized + Clone {
    type Out;

    fn out(&self) -> Self::Out;
    fn apply(
        self,
        state: &mut Vec<Box<dyn Any + 'static, Global>, Global>
    ) -> bool;
}

Required Associated Types

type Out

Required Methods

fn out(&self) -> Self::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

Implementations on Foreign Types

impl<A, B, C, D, E, F, G> UseFutureDep for (&A, &B, &C, &D, &E, &F, &G)where
    A: Dep,
    B: Dep,
    C: Dep,
    D: Dep,
    E: Dep,
    F: Dep,
    G: Dep,

type Out = (A, B, C, D, E, F, G)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F, &G) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B, C, D> UseFutureDep for (&A, &B, &C, &D)where
    A: Dep,
    B: Dep,
    C: Dep,
    D: Dep,

type Out = (A, B, C, D)

fn out(&self) -> <(&A, &B, &C, &D) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B, C, D, E, F> UseFutureDep for (&A, &B, &C, &D, &E, &F)where
    A: Dep,
    B: Dep,
    C: Dep,
    D: Dep,
    E: Dep,
    F: Dep,

type Out = (A, B, C, D, E, F)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A> UseFutureDep for &Awhere
    A: Dep,

type Out = A

fn out(&self) -> <&A as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B, C> UseFutureDep for (&A, &B, &C)where
    A: Dep,
    B: Dep,
    C: Dep,

type Out = (A, B, C)

fn out(&self) -> <(&A, &B, &C) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl UseFutureDep for ()

type Out = ()

fn out(&self) -> <() as UseFutureDep>::Out

fn apply(self, _state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B> UseFutureDep for (&A, &B)where
    A: Dep,
    B: Dep,

type Out = (A, B)

fn out(&self) -> <(&A, &B) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B, C, D, E, F, G, H> UseFutureDep for (&A, &B, &C, &D, &E, &F, &G, &H)where
    A: Dep,
    B: Dep,
    C: Dep,
    D: Dep,
    E: Dep,
    F: Dep,
    G: Dep,
    H: Dep,

type Out = (A, B, C, D, E, F, G, H)

fn out(&self) -> <(&A, &B, &C, &D, &E, &F, &G, &H) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A, B, C, D, E> UseFutureDep for (&A, &B, &C, &D, &E)where
    A: Dep,
    B: Dep,
    C: Dep,
    D: Dep,
    E: Dep,

type Out = (A, B, C, D, E)

fn out(&self) -> <(&A, &B, &C, &D, &E) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

impl<A> UseFutureDep for (&A,)where
    A: Dep,

type Out = (A,)

fn out(&self) -> <(&A,) as UseFutureDep>::Out

fn apply(self, state: &mut Vec<Box<dyn Any + 'static, Global>, Global>) -> bool

Implementors