1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Module for `neq_assign` utility function.

use std::borrow::BorrowMut;
use yew::html::ShouldRender;

/// Blanket trait to provide a convenience method for assigning props in `changed` or updating values in `update`.
pub trait NeqAssign<NEW> {
    /// If `self` and `new` aren't equal, assigns `new` to `self` and returns true, otherwise returns false.
    ///
    /// Short for "Not equal assign".
    ///
    /// # Example
    /// ```
    /// # use yew::{Component, ShouldRender, ComponentLink};
    /// # use yewtil::NeqAssign;
    /// # use yew::Properties;
    ///# use yew::virtual_dom::VNode;
    /// ##[derive(Clone, Properties, PartialEq)]
    ///  struct Props {
    ///     field1: String,
    ///     field2: usize
    ///  }
    ///  struct Model {
    ///     props: Props
    ///  }
    ///  impl Component for Model {
    /// #    type Message = ();
    ///     type Properties = Props;
    ///     // ...
    /// #
    /// #    fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
    /// #        unimplemented!()
    /// #    }
    /// #    fn update(&mut self, msg: ()) -> ShouldRender {
    /// #        unimplemented!()
    /// #    }
    /// #
    ///     fn change(&mut self, props: Self::Properties) -> ShouldRender{
    ///         self.props.neq_assign(props)
    ///     }
    ///#
    ///#     fn view(&self) -> VNode {
    ///#         unimplemented!()
    ///#     }
    ///  }
    ///
    /// let mut foo = 1;
    ///
    /// assert_eq!(foo.neq_assign(42), true);
    /// assert_eq!(foo, 42);
    ///
    /// assert_eq!(foo.neq_assign(42), false);
    /// ```
    fn neq_assign(&mut self, new: NEW) -> ShouldRender;
}

impl<T: BorrowMut<U>, U: PartialEq> NeqAssign<U> for T {
    fn neq_assign(&mut self, new: U) -> bool {
        self.neq_assign_by(new, |x, y| x == y)
    }
}
/// Blanket trait to provide a convenience method for assigning props in `changed` or updating values in `update`.
///
/// Like `neq_assign`, but for cases where `self` doesn't impl `PartialEq` or a nonstandard equality comparison is needed.
///
/// Useful for `Result<T, E: !PartialEq>`.
pub trait NeqAssignBy<NEW> {
    /// ```
    /// # use yewtil::{NeqAssign, NeqAssignBy};
    /// ##[derive(Clone, Debug)]
    /// struct NonComparableError;
    ///
    /// fn eq_by_ok<T, E>(a: &Result<T, E>, b: &Result<T, E>) -> bool
    /// where
    ///     T: PartialEq,
    /// {
    ///     match (a, b) {
    ///         (Ok(_), Err(_))
    ///         | (Err(_), Ok(_))
    ///         | (Err(_), Err(_)) => false,
    ///         (Ok(a), Ok(b)) => a == b,
    ///     }
    /// }
    ///
    /// let mut foo: Result<u32, NonComparableError> = Ok(1);
    ///
    /// // Won't compile
    /// // assert_eq!(foo.neq_assign(Ok(42)), true)
    ///
    /// assert_eq!(foo.neq_assign_by(Ok(42), eq_by_ok), true);
    /// assert_eq!(foo.clone().unwrap(), 42);
    ///
    /// assert_eq!(foo.neq_assign_by(Err(NonComparableError), eq_by_ok), true);
    /// assert!(foo.is_err());
    ///
    /// // The tradeoff: all assignments of an `Err` value will count as updates, even if they are
    /// // "the same" for all practical intents and purposes.
    /// assert_eq!(foo.neq_assign_by(Err(NonComparableError), eq_by_ok), true);
    /// assert_eq!(foo.neq_assign_by(Err(NonComparableError), eq_by_ok), true);
    /// assert_eq!(foo.neq_assign_by(Err(NonComparableError), eq_by_ok), true);
    /// ```
    ///
    fn neq_assign_by<F>(&mut self, new: NEW, eq: F) -> ShouldRender
    where
        F: FnOnce(&NEW, &NEW) -> bool;
}

impl<T: BorrowMut<U>, U> NeqAssignBy<U> for T {
    fn neq_assign_by<F>(&mut self, new: U, eq: F) -> ShouldRender
    where
        F: FnOnce(&U, &U) -> bool,
    {
        if !eq(self.borrow(), &new) {
            *self.borrow_mut() = new;
            true
        } else {
            false
        }
    }
}