Struct patternfly_yew::ContextWrapper

source ·

pub struct ContextWrapper<C>where
    C: Clone + PartialEq + 'static,{ /* private fields */ }

Implementations§

source §

impl<C> ContextWrapper<C>where
C: Clone + PartialEq + 'static,

source

pub fn new(context: Option<(C, ContextHandle<C>)>) -> Self

Examples found in repository ?

src/utils/context.rs (line 33)

    pub fn with<COMP, F>(ctx: &Context<COMP>, cb: F) -> Self
    where
        COMP: BaseComponent,
        F: Fn(C) -> COMP::Message + 'static,
    {
        let cb = ctx.link().callback(cb);
        Self::new(ctx.link().context(cb))
    }

    pub fn set(&mut self, context: C) -> bool {
        let context = Some(context);
        if self.context != context {
            self.context = context;
            true
        } else {
            false
        }
    }
}

impl<C, COMP, F> From<(&Context<COMP>, F)> for ContextWrapper<C>
where
    COMP: Component,
    F: Fn(C) -> COMP::Message + 'static,
    C: PartialEq + Clone,
{
    fn from((ctx, f): (&Context<COMP>, F)) -> Self {
        let link = ctx.link().clone();

        Self::new(link.clone().context(Callback::from(move |v| {
            link.send_message(f(v));
        })))
    }

source

pub fn with<COMP, F>(ctx: &Context<COMP>, cb: F) -> Selfwhere
COMP: BaseComponent,
F: Fn(C) -> COMP::Message + 'static,

source

pub fn set(&mut self, context: C) -> bool

Examples found in repository ?

src/modal.rs (line 82)

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::Close => {
                if let Some(onclose) = &ctx.props().onclose {
                    onclose.emit(());
                } else if let Some(backdrop) = self.backdrop.deref() {
                    backdrop.close();
                }
            }
            Msg::SetBackdrop(backdrop) => {
                self.backdrop.set(backdrop);
            }
        }
        true
    }

More examples

Hide additional examples

src/about.rs (line 54)

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::Close => {
                if let Some(onclose) = &ctx.props().onclose {
                    onclose.emit(());
                } else {
                    if let Some(backdrop) = self.backdrop.deref() {
                        backdrop.close();
                    }
                }
            }
            Msg::SetBackdrop(backdropper) => {
                self.backdrop.set(backdropper);
            }
        }
        true
    }

Methods from Deref<Target = Option<C>>§

1.0.0 · source

pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

pub fn is_none(&self) -> bool

Returns true if the option is a None value.

pub fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");

1.33.0 · source

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

1.33.0 · source

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

1.40.0 · source

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>where
T: Deref,

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

source

pub fn contains(&self, x: &U) -> boolwhere
U: PartialEq<T>,

🔬This is a nightly-only experimental API. (option_result_contains)

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);