Trait kobold::diff::Diff

pub trait Diff: Copy {
    type Memo: 'static;

    // Required methods
    fn into_memo(self) -> Self::Memo;
    fn diff(self, memo: &mut Self::Memo) -> bool;
}

Trait that defines how different values can be diffed at runtime.

Required Associated Types

type Memo: 'static

Data used to check if current value is different from the one in the past.

Required Methods

fn into_memo(self) -> Self::Memo

Generate a new Memo for this type.

fn diff(self, memo: &mut Self::Memo) -> bool

Diff current value against the Memo, update it if necessary and return true if it has changed.

Implementations on Foreign Types

impl Diff for i16

type Memo = i16

fn into_memo(self) -> i16

fn diff(self, memo: &mut i16) -> bool

impl Diff for usize

type Memo = usize

fn into_memo(self) -> usize

fn diff(self, memo: &mut usize) -> bool

impl Diff for u32

type Memo = u32

fn into_memo(self) -> u32

fn diff(self, memo: &mut u32) -> bool

impl Diff for u64

type Memo = u64

fn into_memo(self) -> u64

fn diff(self, memo: &mut u64) -> bool

impl Diff for bool

type Memo = bool

fn into_memo(self) -> bool

fn diff(self, memo: &mut bool) -> bool

impl Diff for isize

type Memo = isize

fn into_memo(self) -> isize

fn diff(self, memo: &mut isize) -> bool

impl Diff for f64

type Memo = f64

fn into_memo(self) -> f64

fn diff(self, memo: &mut f64) -> bool

impl Diff for i64

type Memo = i64

fn into_memo(self) -> i64

fn diff(self, memo: &mut i64) -> bool

impl Diff for &String

type Memo = String

fn into_memo(self) -> String

fn diff(self, memo: &mut String) -> bool

impl Diff for i8

type Memo = i8

fn into_memo(self) -> i8

fn diff(self, memo: &mut i8) -> bool

impl Diff for u16

type Memo = u16

fn into_memo(self) -> u16

fn diff(self, memo: &mut u16) -> bool

impl Diff for u128

type Memo = u128

fn into_memo(self) -> u128

fn diff(self, memo: &mut u128) -> bool

impl Diff for i128

type Memo = i128

fn into_memo(self) -> i128

fn diff(self, memo: &mut i128) -> bool

impl Diff for u8

type Memo = u8

fn into_memo(self) -> u8

fn diff(self, memo: &mut u8) -> bool

impl Diff for i32

type Memo = i32

fn into_memo(self) -> i32

fn diff(self, memo: &mut i32) -> bool

impl Diff for f32

type Memo = f32

fn into_memo(self) -> f32

fn diff(self, memo: &mut f32) -> bool

impl Diff for &str

type Memo = String

fn into_memo(self) -> String

fn diff(self, memo: &mut String) -> bool

Implementors

impl Diff for &VString

type Memo = u64

impl<T> Diff for Eager<T>where T: Copy,

type Memo = ()

impl<T> Diff for Static<T>where T: Copy,

type Memo = ()

impl<T: ?Sized> Diff for &Ref<T>

type Memo = *const ()