Trait react::SafeIntoJsRuntime

pub trait SafeIntoJsRuntime: Sized {
    fn safe_into_js_runtime(self) -> PassedToJsRuntime;
}

Required methods

fn safe_into_js_runtime(self) -> PassedToJsRuntime

Implementations on Foreign Types

impl<F: 'static + ?Sized> SafeIntoJsRuntime for Closure<F>

Closure

fn safe_into_js_runtime(self) -> PassedToJsRuntime

impl<T: SafeIntoJsRuntime> SafeIntoJsRuntime for Box<T>

fn safe_into_js_runtime(self) -> PassedToJsRuntime

Implementors

impl<F: 'static + ?Sized + WasmClosure> SafeIntoJsRuntime for WrapDynFnOrFnMut<F>

impl<F: 'static + WasmClosureFnOnce<A, R>, A, R> SafeIntoJsRuntime for WrapFnOnce<F, A, R>

impl<T> SafeIntoJsRuntime for MutableRefRc<T> where
    dyn Fn(T): WasmClosure,
    T: 'static, 

impl<T: ToJs + FromJs> SafeIntoJsRuntime for MutableRefJs<T>

impl<TFunc, A, B, C, D, E, F, G, H, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C, D, E, F, G, H)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    G: 'static,
    H: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F, G, H) -> R + 'static,
    dyn Fn(A, B, C, D, E, F, G, H) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, D, E, F, G, H, ) -> TR>

impl<TFunc, A, B, C, D, E, F, G, H, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C, D, E, F, G, H)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    G: 'static,
    H: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F, G, H) -> R + 'static,
    dyn FnMut(A, B, C, D, E, F, G, H) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, D, E, F, G, H, ) -> TR>

impl<TFunc, A, B, C, D, E, F, G, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C, D, E, F, G)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    G: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F, G) -> R + 'static,
    dyn Fn(A, B, C, D, E, F, G) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, D, E, F, G, ) -> TR>

impl<TFunc, A, B, C, D, E, F, G, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C, D, E, F, G)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    G: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F, G) -> R + 'static,
    dyn FnMut(A, B, C, D, E, F, G) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, D, E, F, G, ) -> TR>

impl<TFunc, A, B, C, D, E, F, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C, D, E, F)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F) -> R + 'static,
    dyn Fn(A, B, C, D, E, F) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, D, E, F, ) -> TR>

impl<TFunc, A, B, C, D, E, F, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C, D, E, F)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    F: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E, F) -> R + 'static,
    dyn FnMut(A, B, C, D, E, F) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, D, E, F, ) -> TR>

impl<TFunc, A, B, C, D, E, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C, D, E)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E) -> R + 'static,
    dyn Fn(A, B, C, D, E) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, D, E, ) -> TR>

impl<TFunc, A, B, C, D, E, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C, D, E)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    E: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D, E) -> R + 'static,
    dyn FnMut(A, B, C, D, E) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, D, E, ) -> TR>

impl<TFunc, A, B, C, D, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C, D)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D) -> R + 'static,
    dyn Fn(A, B, C, D) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, D, ) -> TR>

impl<TFunc, A, B, C, D, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C, D)> where
    A: 'static,
    B: 'static,
    C: 'static,
    D: 'static,
    R: 'static,
    TFunc: Fn(A, B, C, D) -> R + 'static,
    dyn FnMut(A, B, C, D) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, D, ) -> TR>

impl<TFunc, A, B, C, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B, C)> where
    A: 'static,
    B: 'static,
    C: 'static,
    R: 'static,
    TFunc: Fn(A, B, C) -> R + 'static,
    dyn Fn(A, B, C) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, C, ) -> TR>

impl<TFunc, A, B, C, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B, C)> where
    A: 'static,
    B: 'static,
    C: 'static,
    R: 'static,
    TFunc: Fn(A, B, C) -> R + 'static,
    dyn FnMut(A, B, C) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, C, ) -> TR>

impl<TFunc, A, B, R> SafeIntoJsRuntime for WrapFn<TFunc, (A, B)> where
    A: 'static,
    B: 'static,
    R: 'static,
    TFunc: Fn(A, B) -> R + 'static,
    dyn Fn(A, B) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, B, ) -> TR>

impl<TFunc, A, B, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A, B)> where
    A: 'static,
    B: 'static,
    R: 'static,
    TFunc: Fn(A, B) -> R + 'static,
    dyn FnMut(A, B) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, B, ) -> TR>

impl<TFunc, A, R> SafeIntoJsRuntime for WrapFn<TFunc, (A,)> where
    A: 'static,
    R: 'static,
    TFunc: Fn(A) -> R + 'static,
    dyn Fn(A) -> R: WasmClosure, 

WrapFn<TFunc: Fn(A, ) -> TR>

impl<TFunc, A, R> SafeIntoJsRuntime for WrapFnMut<TFunc, (A,)> where
    A: 'static,
    R: 'static,
    TFunc: Fn(A) -> R + 'static,
    dyn FnMut(A) -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut(A, ) -> TR>

impl<TFunc, R> SafeIntoJsRuntime for WrapFn<TFunc, ()> where
    R: 'static,
    TFunc: Fn() -> R + 'static,
    dyn Fn() -> R: WasmClosure, 

WrapFn<TFunc: Fn() -> TR>

impl<TFunc, R> SafeIntoJsRuntime for WrapFnMut<TFunc, ()> where
    R: 'static,
    TFunc: Fn() -> R + 'static,
    dyn FnMut() -> R: WasmClosure, 

WrapFnMut<TFunc: FnMut() -> TR>