Trait PatchField

pub trait PatchField {
    // Required method
    fn patch_field(
        &mut self,
        new: Self,
        path: &StorePath,
        notify: &mut dyn FnMut(&StorePath),
    );
}

Allows patching a store field with some new value.

Required Methods

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

Patches the field with some new value, only notifying if the value has changed.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl PatchField for &str

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for Cow<'_, str>

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for IpAddr

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for SocketAddr

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for bool

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for char

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for f32

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for f64

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for i8

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for i16

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for i32

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for i64

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for i128

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for isize

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for u8

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for u16

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for u32

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for u64

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for u128

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for ()

fn patch_field( &mut self, _new: Self, _path: &StorePath, _notify: &mut dyn FnMut(&StorePath), )

impl PatchField for usize

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for Rc<str>

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for String

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for Arc<str>

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for Ipv4Addr

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for Ipv6Addr

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for SocketAddrV4

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for SocketAddrV6

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroI8

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroI16

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroI32

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroI64

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroI128

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroIsize

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroU8

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroU16

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroU32

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroU64

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroU128

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl PatchField for NonZeroUsize

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A> PatchField for (A,)

where A: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B> PatchField for (A, B)

where A: PatchField, B: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C> PatchField for (A, B, C)

where A: PatchField, B: PatchField, C: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D> PatchField for (A, B, C, D)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E> PatchField for (A, B, C, D, E)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F> PatchField for (A, B, C, D, E, F)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G> PatchField for (A, B, C, D, E, F, G)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H> PatchField for (A, B, C, D, E, F, G, H)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I> PatchField for (A, B, C, D, E, F, G, H, I)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J> PatchField for (A, B, C, D, E, F, G, H, I, J)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K> PatchField for (A, B, C, D, E, F, G, H, I, J, K)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField, V: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField, V: PatchField, W: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField, V: PatchField, W: PatchField, X: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField, V: PatchField, W: PatchField, X: PatchField, Y: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> PatchField for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: PatchField, B: PatchField, C: PatchField, D: PatchField, E: PatchField, F: PatchField, G: PatchField, H: PatchField, I: PatchField, J: PatchField, K: PatchField, L: PatchField, M: PatchField, N: PatchField, O: PatchField, P: PatchField, Q: PatchField, R: PatchField, S: PatchField, T: PatchField, U: PatchField, V: PatchField, W: PatchField, X: PatchField, Y: PatchField, Z: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<T> PatchField for Option<T>

where T: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

impl<T> PatchField for Vec<T>

where T: PatchField,

fn patch_field( &mut self, new: Self, path: &StorePath, notify: &mut dyn FnMut(&StorePath), )

Implementors