firewheel-core 0.10.1

Shared types for Firewheel crates
Documentation 
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

//! A set of diff and patch implementations for common collections.

use super::{Diff, EventQueue, Patch, PatchError, PathBuilder};
use crate::event::ParamData;

#[cfg(not(feature = "std"))]
use bevy_platform::prelude::{Box, Vec};

macro_rules! sequence_diff {
    ($gen:ident, $ty:ty) => {
        impl<$gen: Diff> Diff for $ty {
            fn diff<E: EventQueue>(&self, baseline: &Self, path: PathBuilder, event_queue: &mut E) {
                for (i, item) in self.iter().enumerate() {
                    item.diff(&baseline[i], path.with(i as u32), event_queue);
                }
            }
        }

        impl<$gen: Patch> Patch for $ty {
            type Patch = (usize, $gen::Patch);

            fn patch(data: &ParamData, path: &[u32]) -> Result<Self::Patch, PatchError> {
                let first = *path.first().ok_or(PatchError::InvalidPath)?;
                let inner = $gen::patch(data, &path[1..])?;

                Ok((first as usize, inner))
            }

            fn apply(&mut self, patch: Self::Patch) {
                self[patch.0].apply(patch.1);
            }
        }
    };
}

sequence_diff!(T, Vec<T>);
sequence_diff!(T, Box<[T]>);
sequence_diff!(T, [T]);

impl<T: Diff, const LEN: usize> Diff for [T; LEN] {
    fn diff<E: EventQueue>(&self, baseline: &Self, path: PathBuilder, event_queue: &mut E) {
        for (i, item) in self.iter().enumerate() {
            item.diff(&baseline[i], path.with(i as u32), event_queue);
        }
    }
}

impl<T: Patch, const LEN: usize> Patch for [T; LEN] {
    type Patch = (usize, T::Patch);

    fn patch(data: &ParamData, path: &[u32]) -> Result<Self::Patch, PatchError> {
        let first = *path.first().ok_or(PatchError::InvalidPath)? as usize;
        if first >= LEN {
            return Err(PatchError::InvalidPath);
        }
        let inner = T::patch(data, &path[1..])?;

        Ok((first, inner))
    }

    fn apply(&mut self, patch: Self::Patch) {
        self[patch.0].apply(patch.1);
    }
}

macro_rules! tuple_diff {
    ($tup:ident, $($gen:ident, $base:ident, $index:literal),*) => {
        pub enum $tup<$($gen: Patch),*> {
            $($gen($gen::Patch)),*
        }

        #[allow(non_snake_case, unused_variables)]
        impl<$($gen: Diff),*> Diff for ($($gen,)*) {
            fn diff<EQ: EventQueue>(&self, baseline: &Self, path: PathBuilder, event_queue: &mut EQ) {
                let ($($gen,)*) = self;
                let ($($base,)*) = baseline;

                $(
                    $gen.diff($base, path.with($index), event_queue);
                )*
            }
        }

        #[allow(non_snake_case, unused_variables)]
        impl<$($gen: Patch),*> Patch for ($($gen,)*) {
            type Patch = $tup<$($gen),*>;

            fn patch(data: &ParamData, path: &[u32]) -> Result<Self::Patch, PatchError> {
                match path {
                    $(
                        [$index, tail @ ..] => Ok($tup::$gen($gen::patch(data, tail)?)),
                    )*
                    _ => Err(PatchError::InvalidPath),
                }
            }

            fn apply(&mut self, patch: Self::Patch) {
                let ($($gen,)*) = self;

                match patch {
                    $(
                        $tup::$gen(p) => $gen.apply(p)
                    ),*
                }
            }
        }
    };
}

tuple_diff!(Tuple1, A, A1, 0);
tuple_diff!(Tuple2, A, A1, 0, B, B1, 1);
tuple_diff!(Tuple3, A, A1, 0, B, B1, 1, C, C1, 2);
tuple_diff!(Tuple4, A, A1, 0, B, B1, 1, C, C1, 2, D, D1, 3);
tuple_diff!(Tuple5, A, A1, 0, B, B1, 1, C, C1, 2, D, D1, 3, E, E1, 4);
tuple_diff!(Tuple6, A, A1, 0, B, B1, 1, C, C1, 2, D, D1, 3, E, E1, 4, F, F1, 5);
tuple_diff!(Tuple7, A, A1, 0, B, B1, 1, C, C1, 2, D, D1, 3, E, E1, 4, F, F1, 5, G, G1, 6);
tuple_diff!(Tuple8, A, A1, 0, B, B1, 1, C, C1, 2, D, D1, 3, E, E1, 4, F, F1, 5, G, G1, 6, H, H1, 7);