vsrg 0.6.0

/// Generates note enum and storage of all note types.
///
/// # Remarks
/// This macro generates:
/// - A note type enum, which is fieldless. Used to identify the note type.
/// - A note enum, holding one note record per variant. Represents a note's content.
/// - A snapshot enum, holding one owned [`crate::notes::NoteSnapshot`] per variant.
/// - A note reference enum, holding one [`crate::notes::NoteRef`] per variant. It holds both the
///   note's content ([`crate::notes::NoteRef::value_data`]), and the note's runtime state
///   ([`crate::notes::NoteRef::runtime_data`]).
/// - A note mut reference enum, holding one [`crate::notes::NoteMut`] per variant. It's similar to
///   the reference enum but allows mutating runtime state.
/// - The notes storage struct, holding either [`crate::notes::ShortNoteTypeStorage`] or
///   [`crate::notes::LongNoteTypeStorage`] for each note type, plus any other field that was
///   specified.
///
/// It also implements ergonomic methods for each generated type.
/// Each note storage field gets a `set_<field_name>_state(id, note_state)` method
/// that replaces the note's runtime data in both indexes, ignoring missing ids.
///
/// Edit hooks can be provided. Each entry registers a value implementing [`NotesStorageEditHook`],
/// whose methods fire for every notes storage edit operation (add, remove, update note).
///
/// Each note is assigned a u64 id. Ids are only unique within each note storage, or in other
/// words, notes of different types may share the same numerical id. The user must take care to
/// keep track of the type of each id. Note ids are used by `remove_note(s)` and `replace_note(s)`
/// to identify the target note(s).
///
/// # Examples:
/// ```
///    use vsrg::rhythm::{Time, ClockTime};
///    use vsrg::notes::{
///        ShortNoteTypeStorage, LongNoteTypeStorage, GroupId, Interval,
///        ShortNoteData, LongNoteData,
///    };
///    use soa_rs::{Soars, SoaClone};
///
///    vsrg::generate_notes_storage! {
///        enum MyNoteType,
///
///        enum MyNote,
///
///        enum MyNoteSnapshot,
///
///        enum MyNoteRef,
///
///        enum MyNoteMut,
///
///        #[derive(Debug, Clone)]
///        struct MyNotesStorage {
///            note_type Short(MyShort) => shorts: ShortNoteTypeStorage<MyShort>,
///            note_type Long(MyLong) => longs: LongNoteTypeStorage<MyLong>,
///        }
///    }
///
///    #[derive(Debug, Clone, PartialEq)]
///    struct MyShort {
///        time: Time,
///        gr_id: GroupId,
///        pos: f32,
///    }
///
///    #[derive(Debug, Clone, PartialEq)]
///    struct MyLong {
///        time: Interval<Time>,
///        gr_id: GroupId,
///        pos: f32,
///    }
///
///    #[derive(Clone, Copy, soa_rs::Soars, soa_rs::SoaClone)]
///    pub struct NoteData(f32);
///    #[derive(Clone, Copy, soa_rs::Soars, soa_rs::SoaClone, Default)]
///    pub struct NoteRuntime(f32);
///    impl ShortNoteData for MyShort {
///        type ValueData = NoteData;
///        type RuntimeData = NoteRuntime;
///        fn time(&self) -> Time {
///            self.time
///        }
///        fn group_id(&self) -> GroupId {
///            self.gr_id
///        }
///        fn value_data(&self) -> Self::ValueData {
///            NoteData(self.pos)
///        }
///        fn reconstruct<'a>(
///            time: Time,
///            data: <Self::ValueData as soa_rs::Soars>::Ref<'a>,
///            gr_id: GroupId,
///        ) -> Self {
///            Self {
///                time,
///                gr_id,
///                pos: *data.0,
///            }
///        }
///    }
///    impl LongNoteData for MyLong {
///        type ValueData = NoteData;
///        type RuntimeData = NoteRuntime;
///        fn start_time(&self) -> Time {
///            self.time.start()
///        }
///        fn duration(&self) -> Time {
///            generativity::make_guard!(guard);
///            let (start, end) = self.time.start().prove_same_unit(self.time.end(), guard)
///                .expect("test interval endpoints use the same time unit");
///            (end - start).as_time()
///        }
///        fn group_id(&self) -> GroupId {
///            self.gr_id
///        }
///        fn value_data(&self) -> Self::ValueData {
///            NoteData(self.pos)
///        }
///        fn reconstruct<'a>(
///            start_time: Time,
///            duration: Time,
///            data: <Self::ValueData as soa_rs::Soars>::Ref<'a>,
///            gr_id: GroupId,
///        ) -> Self {
///            generativity::make_guard!(guard);
///            let (start, duration) = start_time.prove_same_unit(duration, guard)
///                .expect("test note timing uses the same time unit");
///            let time = Interval::try_new(start_time, (start + duration).as_time()).unwrap();
///            Self {
///                time,
///                gr_id,
///                pos: *data.0,
///            }
///        }
///    }
/// ```
///
/// For more advanced demonstrations, please refer to the examples of this crate.
#[macro_export]
macro_rules! generate_notes_storage {
    (
        $(#[$note_ty_meta:meta])*
        $note_ty_enum_vis:vis enum $note_ty_enum_name:ident,

        $(#[$note_enum_meta:meta])*
        $note_enum_vis:vis enum $note_enum_name:ident,

        $(#[$snapshot_meta:meta])*
        $snapshot_vis:vis enum $snapshot_name:ident,

        $(#[$note_ref_meta:meta])*
        $note_ref_vis:vis enum $note_ref_name:ident,

        $(#[$note_mut_meta:meta])*
        $note_mut_vis:vis enum $note_mut_name:ident,

        $(#[$struct_meta:meta])*
        $struct_vis:vis struct $struct_name:ident {
            $(note_type $enum_variant:ident ($variant_ty:ty) => $field_vis: vis $field_name:ident: $storage_type: ty),*
            $(, field $aux_vis: vis $aux_field:ident: $aux_ty:ty)*
            $(, edit_hook $hook:expr)* $(,)?
        }
    ) => {
        /// Enum of all note types.
        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
        $(#[$note_ty_meta])*
        $note_ty_enum_vis enum $note_ty_enum_name {
            $($enum_variant,)*
        }

        /// Enum of all note types, with each variant holding the note's content.
        ///
        /// # Remarks
        /// Each note variant only contains the note's canonical value (the minimal data necessary
        /// to identify the note), and contains no runtime state.
        #[derive(Debug, Clone)]
        $(#[$note_enum_meta])*
        $note_enum_vis enum $note_enum_name {
            $($enum_variant($variant_ty),)*
        }

        /// Owned snapshot of a note, including its identity, timing, and runtime state.
        #[derive(Clone)]
        $(#[$snapshot_meta])*
        $snapshot_vis enum $snapshot_name {
            $($enum_variant($crate::notes::NoteSnapshot<$variant_ty>),)*
        }

        #[allow(dead_code)]
        impl $snapshot_name {
            pub fn note_type(&self) -> $note_ty_enum_name {
                match self {
                    $(Self::$enum_variant(_) => $note_ty_enum_name::$enum_variant,)*
                }
            }

            pub fn id(&self) -> u64 {
                match self {
                    $(Self::$enum_variant(n) => n.id,)*
                }
            }

            pub fn start_time(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::Note::start_time(n),)*
                }
            }

            pub fn duration(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::Note::duration(n),)*
                }
            }

            pub fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                match self {
                    $(Self::$enum_variant(n) => n.clock_time,)*
                }
            }

            pub fn group_id(&self) -> $crate::notes::GroupId {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::Note::group_id(n),)*
                }
            }

            /// Clone the canonical note value, excluding runtime state.
            pub fn to_owned_note(&self) -> $note_enum_name {
                match self {
                    $(Self::$enum_variant(n) => $note_enum_name::$enum_variant(n.note.clone()),)*
                }
            }

            /// Consume this snapshot and take its canonical note value.
            pub fn into_owned_note(self) -> $note_enum_name {
                match self {
                    $(Self::$enum_variant(n) => $note_enum_name::$enum_variant(n.note),)*
                }
            }
        }

        impl $crate::notes::Note for $snapshot_name {
            fn start_time(&self) -> $crate::rhythm::Time {
                self.start_time()
            }
            fn duration(&self) -> $crate::rhythm::Time {
                self.duration()
            }
            fn group_id(&self) -> $crate::notes::GroupId {
                self.group_id()
            }
        }

        impl $crate::notes::NoteState for $snapshot_name {
            type Snapshot = Self;
            fn to_snapshot(&self) -> Self {
                self.clone()
            }
            fn id(&self) -> u64 {
                self.id()
            }
            fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                self.clock_time_interval()
            }
        }

        impl From<&$snapshot_name> for $note_ty_enum_name {
            fn from(note: &$snapshot_name) -> Self {
                note.note_type()
            }
        }

        impl From<&$snapshot_name> for $note_enum_name {
            fn from(note: &$snapshot_name) -> Self {
                note.to_owned_note()
            }
        }

        impl From<$snapshot_name> for $note_enum_name {
            fn from(note: $snapshot_name) -> Self {
                note.into_owned_note()
            }
        }

        impl From<&$note_enum_name> for $note_ty_enum_name {
            fn from(val: &$note_enum_name) -> Self {
                val.note_type()
            }
        }

        impl From<$note_enum_name> for $note_ty_enum_name {
            fn from(val: $note_enum_name) -> Self {
                val.note_type()
            }
        }

        #[allow(dead_code)]
        impl $note_enum_name {
            pub fn note_type(&self) -> $note_ty_enum_name {
                match self {
                    $(Self::$enum_variant(_) => $note_ty_enum_name::$enum_variant,)*
                }
            }

            pub fn start_time(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::LongNoteData::start_time(n),)*
                }
            }

            pub fn duration(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::LongNoteData::duration(n),)*
                }
            }

            pub fn group_id(&self) -> $crate::notes::GroupId {
                match self {
                    $(Self::$enum_variant(n) => $crate::notes::LongNoteData::group_id(n),)*
                }
            }
        }

        /// Reference to a note in the notes storage.
        ///
        /// # Remarks
        /// This contains both its canonical value and readonly reference to its runtime state.
        /// Returned by the notes storage's querying methods.
        $(#[$note_ref_meta])*
        #[allow(unused)]
        $note_ref_vis enum $note_ref_name<'a> {
            $($enum_variant($crate::notes::NoteRef<'a, $variant_ty>),)*
        }

        #[allow(dead_code)]
        impl $note_ref_name<'_> {
            /// The storage id, unique within this note type.
            pub fn id(&self) -> u64 {
                match self {
                    $(Self::$enum_variant(n) => n.id,)*
                }
            }

            pub fn start_time(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => n.start_time,)*
                }
            }

            pub fn duration(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => n.duration,)*
                }
            }

            pub fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                match self {
                    $(Self::$enum_variant(n) => n.clock_time,)*
                }
            }

            pub fn group_id(&self) -> $crate::notes::GroupId {
                match self {
                    $(Self::$enum_variant(n) => n.group_id,)*
                }
            }

            /// Clone the stored value, runtime state, identity, and clock timing into an owned snapshot.
            pub fn to_snapshot(&self) -> $snapshot_name {
                match self {
                    $(Self::$enum_variant(n) => $snapshot_name::$enum_variant(n.to_snapshot()),)*
                }
            }

            /// Copy the stored value into an owned value.
            pub fn to_owned_note(&self) -> $note_enum_name {
                match self {
                    $(Self::$enum_variant(n) => $note_enum_name::$enum_variant(
                        <$variant_ty as $crate::notes::LongNoteData>::reconstruct(
                            n.start_time, n.duration, n.value_data, n.group_id.clone(),
                        ),
                    ),)*
                }
            }
        }

        /// Mutable reference to a note in the notes storage.
        ///
        /// # Remarks
        /// This contains both its canonical value and mutable reference to its runtime state.
        /// Returned by the notes storage's querying methods.
        $(#[$note_mut_meta])*
        #[allow(unused)]
        $note_mut_vis enum $note_mut_name<'a> {
            $($enum_variant($crate::notes::NoteMut<'a, $variant_ty>),)*
        }

        #[allow(dead_code)]
        impl $note_mut_name<'_> {
            /// Borrow a read-only view for the duration of this shared borrow.
            pub fn as_ref(&self) -> $note_ref_name<'_> {
                match self {
                    $(Self::$enum_variant(n) => $note_ref_name::$enum_variant(n.as_ref()),)*
                }
            }

            /// The storage id, unique within this note type.
            pub fn id(&self) -> u64 {
                match self {
                    $(Self::$enum_variant(n) => n.id,)*
                }
            }

            pub fn start_time(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => n.start_time,)*
                }
            }

            pub fn duration(&self) -> $crate::rhythm::Time {
                match self {
                    $(Self::$enum_variant(n) => n.duration,)*
                }
            }

            pub fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                match self {
                    $(Self::$enum_variant(n) => n.clock_time,)*
                }
            }

            pub fn group_id(&self) -> $crate::notes::GroupId {
                match self {
                    $(Self::$enum_variant(n) => n.group_id,)*
                }
            }

            /// Clone the stored value, runtime state, identity, and clock timing into an owned snapshot.
            pub fn to_snapshot(&self) -> $snapshot_name {
                match self {
                    $(Self::$enum_variant(n) => $snapshot_name::$enum_variant(n.to_snapshot()),)*
                }
            }

            /// Copy the stored value into an owned value.
            pub fn to_owned_note(&self) -> $note_enum_name {
                match self {
                    $(Self::$enum_variant(n) => $note_enum_name::$enum_variant(
                        <$variant_ty as $crate::notes::LongNoteData>::reconstruct(
                            n.start_time, n.duration, n.value_data, n.group_id.clone(),
                        ),
                    ),)*
                }
            }
        }

        impl<'a, 'b> From<&'a $note_mut_name<'b>> for $note_ref_name<'a> {
            fn from(note: &'a $note_mut_name<'b>) -> Self {
                note.as_ref()
            }
        }

        impl From<&$note_ref_name<'_>> for $note_enum_name {
            fn from(note: &$note_ref_name<'_>) -> Self {
                note.to_owned_note()
            }
        }

        impl From<&$note_mut_name<'_>> for $note_enum_name {
            fn from(note: &$note_mut_name<'_>) -> Self {
                note.to_owned_note()
            }
        }

        impl From<$note_ref_name<'_>> for $note_enum_name {
            fn from(note: $note_ref_name<'_>) -> Self {
                note.to_owned_note()
            }
        }

        impl From<$note_mut_name<'_>> for $note_enum_name {
            fn from(note: $note_mut_name<'_>) -> Self {
                note.to_owned_note()
            }
        }

        impl $crate::notes::Note for $note_enum_name {
            fn start_time(&self) -> $crate::rhythm::Time {
                $note_enum_name::start_time(self)
            }

            fn duration(&self) -> $crate::rhythm::Time {
                $note_enum_name::duration(self)
            }

            fn group_id(&self) -> $crate::notes::GroupId {
                $note_enum_name::group_id(self)
            }
        }

        impl $crate::notes::Note for $note_ref_name<'_> {
            fn start_time(&self) -> $crate::rhythm::Time {
                $note_ref_name::start_time(self)
            }

            fn duration(&self) -> $crate::rhythm::Time {
                $note_ref_name::duration(self)
            }

            fn group_id(&self) -> $crate::notes::GroupId {
                $note_ref_name::group_id(self)
            }
        }

        impl $crate::notes::NoteState for $note_ref_name<'_> {
            type Snapshot = $snapshot_name;

            fn to_snapshot(&self) -> Self::Snapshot {
                $note_ref_name::to_snapshot(self)
            }

            fn id(&self) -> u64 {
                $note_ref_name::id(self)
            }

            fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                $note_ref_name::clock_time_interval(self)
            }
        }

        impl $crate::notes::Note for $note_mut_name<'_> {
            fn start_time(&self) -> $crate::rhythm::Time {
                $note_mut_name::start_time(self)
            }

            fn duration(&self) -> $crate::rhythm::Time {
                $note_mut_name::duration(self)
            }

            fn group_id(&self) -> $crate::notes::GroupId {
                $note_mut_name::group_id(self)
            }
        }

        impl $crate::notes::NoteState for $note_mut_name<'_> {
            type Snapshot = $snapshot_name;

            fn to_snapshot(&self) -> Self::Snapshot {
                $note_mut_name::to_snapshot(self)
            }

            fn id(&self) -> u64 {
                $note_mut_name::id(self)
            }

            fn clock_time_interval(&self) -> $crate::notes::Interval<$crate::rhythm::ClockTime> {
                $note_mut_name::clock_time_interval(self)
            }
        }

        /// Storage for all generated note types.
        ///
        /// # Data model
        /// Each note type has its own storage with fast O(log N) timing and scroll position
        /// lookup. The storage stores each note in struct-of-array style for good cache
        /// locality during note judgement and note rendering.
        ///
        /// Each note stores separately its *canonical value* (minimum information necessary to
        /// identify the note - usually its serialized value), and its *runtime state* (to support
        /// judgement and rendering).
        ///
        /// # Encapsulation
        /// Edits to runtime state are safe to do directly, while edits to canonical value must be
        /// done by the notes storage's editing methods: [`Self::add_note`], [`Self::remove_note`], etc.
        /// These methods ensure that all notes are sorted correctly for fast lookup, and note
        /// relationships are correctly calculated.
        $(#[$struct_meta])*
        $struct_vis struct $struct_name {
            $($field_vis $field_name: $storage_type,)*
            $($aux_vis $aux_field: $aux_ty,)*
        }

        #[allow(dead_code)]
        impl $struct_name {
            $(
                #[doc = concat!("Shared reference to the `", stringify!($field_name), "` note storage.")]
                #[inline]
                pub fn $field_name(&self) -> &$storage_type {
                    &self.$field_name
                }
            )*

            /// Create a new empty notes storage.
            pub fn new() -> Self {
                Self {
                    $($field_name: Default::default(),)*
                    $($aux_field: Default::default(),)*
                }
            }

            /// Create a notes storage with initial notes.
            pub fn with_notes<G: $crate::notes::NoteGroup>(
                notes: Vec<$note_enum_name>,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
            ) -> Self {
                let mut s = Self::new();
                $crate::notes::NotesStorage::add_notes(
                    &mut s, note_groups, tempo_tracks, scroll_tracks, notes
                );
                s
            }
        }

        impl $crate::notes::NotesStorage for $struct_name {
            type NoteTypeEnum = $note_ty_enum_name;
            type NoteEnum = $note_enum_name;
            type NoteSnapshotEnum = $snapshot_name;
            type NoteRefEnum<'a> = $note_ref_name<'a>;
            type NoteMutEnum<'a> = $note_mut_name<'a>;

            fn rebuild_clock_time<G: $crate::notes::NoteGroup>(
                &mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
            ) {
                $(self.$field_name.rebuild_clock_time(
                        note_groups,
                        tempo_tracks,
                        scroll_tracks);)*
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                $crate::notes::NotesStorageEditHook::post_rebuild_clock_time(&mut hooks, self);
            }

            fn rebuild_scroll_pos<G: $crate::notes::NoteGroup>(
                &mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
            ) {
                $(self.$field_name.rebuild_scroll_pos(
                        note_groups,
                        tempo_tracks,
                        scroll_tracks);)*
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                $crate::notes::NotesStorageEditHook::post_rebuild_scroll_pos(&mut hooks, self);
            }

            /// Add a single note to the notes storage.
            fn add_note<G: $crate::notes::NoteGroup>(
                &mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
                mut note: $note_enum_name,
            ) -> u64 {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                $crate::notes::NotesStorageEditHook::pre_add(&mut hooks, self, ::std::slice::from_mut(&mut note));
                match note {
                    $($note_enum_name::$enum_variant(n) => {
                        let note_id = self.$field_name.add_note(
                            note_groups,
                            tempo_tracks,
                            scroll_tracks,
                            n);
                        $crate::notes::NotesStorageEditHook::post_add(
                            &mut hooks,
                            self,
                            &[(note_id, $note_ty_enum_name::$enum_variant)],
                        );

                        note_id
                    })*
                }
            }

            /// Add multiple notes to the notes storage.
            fn add_notes<G: $crate::notes::NoteGroup>(&mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
                mut notes: ::std::vec::Vec<$note_enum_name>,
            ) -> Vec<(u64, $note_ty_enum_name)> {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                if !notes.is_empty() {
                    $crate::notes::NotesStorageEditHook::pre_add(&mut hooks, self, &mut notes);
                }
                let mut added = ::std::vec::Vec::with_capacity(notes.len());
                $(let mut $field_name: ::std::vec::Vec<$variant_ty> = ::std::vec::Vec::new();)*
                for note in notes {
                    match note {
                        $($note_enum_name::$enum_variant(n) => $field_name.push(n),)*
                    }
                }
                $(
                    if !$field_name.is_empty() {
                        let note_ids = self.$field_name.add_notes(
                            note_groups,
                            tempo_tracks,
                            scroll_tracks,
                            $field_name.into_iter());
                        added.extend(note_ids.into_iter().map(|id| (id, $note_ty_enum_name::$enum_variant)));
                    }
                )*
                if !added.is_empty() {
                    $crate::notes::NotesStorageEditHook::post_add(&mut hooks, self, &added);
                }
                added
            }

            /// Remove a single note from the notes storage.
            ///
            /// Silently does nothing if the id does not exist in the notes storage of the given note
            /// type.
            fn remove_note(&mut self, note_type: $note_ty_enum_name, id: u64) {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                match note_type {
                    $($note_ty_enum_name::$enum_variant => {
                        let queried = self.$field_name.query_notes_ref(::std::iter::once(id))
                            .map(|state| $note_ref_name::$enum_variant(state).to_snapshot()).next();
                        let Some(note) = queried else {
                            return;
                        };
                        let note_id = note.id();
                        $crate::notes::NotesStorageEditHook::pre_remove(
                            &mut hooks,
                            self,
                            ::std::slice::from_ref(&note),
                        );
                        self.$field_name.remove_note(note_id);
                        $crate::notes::NotesStorageEditHook::post_remove(&mut hooks, self, ::std::slice::from_ref(&note));
                    })*
                }
            }

            /// Remove multiple notes from the notes storage.
            ///
            /// Duplicate ids are deduplicated, and ids that do not exist are silently skipped.
            fn remove_notes(&mut self,
                mut notes: ::std::vec::Vec<(u64, $note_ty_enum_name)>,
            ) {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                // Reuse the caller's buffer for sorting and deduplication.
                notes.sort_unstable_by_key(|(id, ty)| (*ty as usize, *id));
                notes.dedup();
                let queried: ::std::vec::Vec<_> = self.query_notes(notes.iter().copied()).collect();
                if !queried.is_empty() {
                    $crate::notes::NotesStorageEditHook::pre_remove(&mut hooks, self, &queried);
                }
                $(
                    self.$field_name.remove_notes(queried.iter().filter_map(|note| {
                        (note.note_type() == $note_ty_enum_name::$enum_variant).then_some(note.id())
                    }));
                )*
                if !queried.is_empty() {
                    $crate::notes::NotesStorageEditHook::post_remove(&mut hooks, self, &queried);
                }
            }

            /// Query for owned snapshots of notes by its ids and note type.
            ///
            /// Since ids are only unique within each note type, a note must also be identified by
            /// its note type as well as its ids.
            fn query_notes(&self,
                ids: impl Iterator<Item = (u64, $note_ty_enum_name)> + Clone
            ) -> impl Iterator<Item = $snapshot_name> {
                ::std::iter::empty()
                $(.chain(self.$field_name.query_notes_ref(
                    #[allow(unreachable_patterns)]
                    ids.clone().filter_map(|(id, ty)| match ty {
                        $note_ty_enum_name::$enum_variant => Some(id),
                        _ => None,
                    })
                ).map(|state| $note_ref_name::$enum_variant(state).to_snapshot())))*
            }

            fn all_notes(&self) -> impl Iterator<Item = $snapshot_name> {
                ::std::iter::empty()
                $(.chain(self.$field_name.all_notes_ref()
                    .map(|state| $note_ref_name::$enum_variant(state).to_snapshot())))*
            }

            fn all_notes_of_type(&self,
                note_type: $note_ty_enum_name,
            ) -> impl Iterator<Item = $snapshot_name> {
                self.all_notes_ref_of_type(note_type).map(|state| state.to_snapshot())
            }

            fn all_notes_ref_of_type<'a>(&'a self,
                note_type: $note_ty_enum_name,
            ) -> impl Iterator<Item = $note_ref_name<'a>> + 'a
            where
                Self: 'a,
            {
                ::std::iter::empty()
                $(.chain(
                    ::std::iter::once(&self.$field_name)
                        .filter(move |_| matches!(note_type, $note_ty_enum_name::$enum_variant))
                        .flat_map(|storage| storage.all_notes_ref())
                        .map($note_ref_name::$enum_variant)
                ))*
            }

            fn all_notes_mut_of_type(&mut self,
                note_type: $note_ty_enum_name,
                mut f: impl FnMut($note_mut_name<'_>),
            ) {
                match note_type {
                    $($note_ty_enum_name::$enum_variant => {
                        self.$field_name.all_notes_mut(
                            |state| f($note_mut_name::$enum_variant(state)),
                        );
                    })*
                }
            }

            /// Get references to note state from the notes storage by its ids and note type.
            ///
            /// Since ids are only unique within each note type, a note must also be identified by
            /// its note type as well as its ids.
            fn query_notes_ref<'a>(&'a self,
                ids: impl Iterator<Item = (u64, $note_ty_enum_name)> + Clone + 'a
            ) -> impl Iterator<Item = $note_ref_name<'a>> + 'a
            where
                Self: 'a
            {
                ::std::iter::empty()
                $(
                    .chain(
                        self.$field_name.query_notes_ref(
                            #[allow(unreachable_patterns)]
                            ids.clone().filter_map(|(id, note_type)| match note_type {
                                $note_ty_enum_name::$enum_variant => Some(id),
                                _ => None,
                            })
                        ).map(|state| $note_ref_name::$enum_variant(state))
                    )
                )*
            }

            /// Get mutable references to note state from the notes storage by ids and note type.
            ///
            /// Mutable references cannot be returned from an iterator (rust's AXM rule), so each
            /// note state is lent to a callback instead. Duplicate ids in `ids` are allowed.
            ///
            /// Since ids are only unique within each note type, a note must also be identified by
            /// its note type as well as its ids.
            fn query_notes_mut(&mut self,
                ids: impl Iterator<Item = (u64, $note_ty_enum_name)> + Clone,
                mut f: impl FnMut($note_mut_name<'_>),
            ) {
                $(
                    self.$field_name.query_notes_mut(
                        #[allow(unreachable_patterns)]
                        ids.clone().filter_map(|(id, note_type)| match note_type {
                            $note_ty_enum_name::$enum_variant => Some(id),
                            _ => None,
                        }),
                        |state| f($note_mut_name::$enum_variant(state)),
                    );
                )*
            }

            /// Query for owned snapshots of notes that overlap a clock-time range.
            fn notes_overlapping_range(&self,
                range: $crate::notes::Interval<$crate::rhythm::ClockTime>
            ) -> impl Iterator<Item = $snapshot_name> {
                self.notes_ref_overlapping_range(range).map(|state| state.to_snapshot())
            }

            /// Get references to state of notes that overlap a clock-time range.
            fn notes_ref_overlapping_range<'a>(&'a self,
                range: $crate::notes::Interval<$crate::rhythm::ClockTime>
            ) -> impl Iterator<Item = $note_ref_name<'a>> + 'a
            where
                Self: 'a
            {
                ::std::iter::empty()
                $(
                    .chain(
                        self.$field_name.notes_ref_overlapping_range(range)
                            .map(|state| $note_ref_name::$enum_variant(state))
                    )
                )*
            }

            /// Get mutable references to notes that overlap a clock-time range.
            ///
            /// Like [`Self::query_notes_mut`], mutable references cannot be returned
            /// from an iterator (rust's AXM rule), so each note state is lent to a callback
            /// instead. Duplicate ids in `ids` are allowed.
            fn notes_mut_overlapping_range(&mut self,
                range: $crate::notes::Interval<$crate::rhythm::ClockTime>,
                mut f: impl FnMut($note_mut_name<'_>),
            ) {
                $(
                    self.$field_name.notes_mut_overlapping_range(
                        range,
                        |state| f($note_mut_name::$enum_variant(state)),
                    );
                )*
            }

            /// Remove multiple notes from the notes storage, running a closure on each note.
            ///
            /// Duplicate ids are deduplicated, and ids that do not exist are silently skipped.
            fn extract_notes(&mut self,
                mut notes: ::std::vec::Vec<(u64, $note_ty_enum_name)>,
                mut f: impl FnMut($snapshot_name),
            ) {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                // Reuse the caller's buffer for sorting and deduplication.
                notes.sort_unstable_by_key(|(id, ty)| (*ty as usize, *id));
                notes.dedup();
                let queried: ::std::vec::Vec<_> = self.query_notes(notes.iter().copied()).collect();
                if !queried.is_empty() {
                    $crate::notes::NotesStorageEditHook::pre_remove(&mut hooks, self, &queried);
                }
                $(
                    self.$field_name.remove_notes(queried.iter().filter_map(|note| {
                        (note.note_type() == $note_ty_enum_name::$enum_variant).then_some(note.id())
                    }));
                )*
                for note in &queried { f(note.clone()); }
                if !queried.is_empty() {
                    $crate::notes::NotesStorageEditHook::post_remove(&mut hooks, self, &queried);
                }
            }

            /// Replace a note with new data.
            ///
            /// Silently does nothing if the id does not exist in the notes storage of the note's type.
            fn replace_note<G: $crate::notes::NoteGroup>(&mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
                id: u64,
                note: $note_enum_name,
            ) {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                let note_type = note.note_type();
                let queried = self
                    .query_notes(::std::iter::once((id, note_type)))
                    .next();
                let Some(before) = queried else {
                    return;
                };
                let note_id = before.id();
                let mut replacement = (note_id, note);
                $crate::notes::NotesStorageEditHook::pre_update(
                    &mut hooks, self, ::std::slice::from_mut(&mut replacement),
                );
                match replacement.1 {
                    $($note_enum_name::$enum_variant(n) => {
                        self.$field_name.replace_note(
                            note_groups,
                            tempo_tracks,
                            scroll_tracks,
                            note_id,
                            n);
                    })*
                }
                let after = self
                    .query_notes(::std::iter::once((note_id, before.note_type())))
                    .next();
                if let Some(after) = after {
                    $crate::notes::NotesStorageEditHook::post_update(
                        &mut hooks,
                        self,
                        &[(before, after)],
                    );
                }
            }

            /// Replace multiple notes with new data.
            ///
            /// When multiple pairs share the same note type and id, the last pair wins. Missing notes
            /// are silently skipped.
            fn replace_notes<G: $crate::notes::NoteGroup>(&mut self,
                note_groups: &$crate::notes::NoteGroups<G>,
                tempo_tracks: &$crate::rhythm::TempoTracks,
                scroll_tracks: &$crate::rhythm::ScrollSpeedTracks,
                mut notes: ::std::vec::Vec<(u64, $note_enum_name)>,
            ) {
                let mut hooks = $crate::generate_notes_storage!(@edit_hooks_tuple $($hook),*);
                // Stable sorting after reversing keeps the last supplied value for each
                // (type, id) when deduplicating.
                notes.reverse();
                notes.sort_by_key(|(id, note)| (note.note_type() as usize, *id));
                notes.dedup_by_key(|(id, note)| (note.note_type() as usize, *id));
                let mut befores: ::std::vec::Vec<_> = self
                    .query_notes(notes.iter().map(|(id, note)| (*id, note.note_type())))
                    .collect();
                befores.sort_unstable_by_key(|note| (note.note_type() as usize, note.id()));
                notes.retain(|(id, note)| befores.binary_search_by_key(
                    &(note.note_type() as usize, *id),
                    |before| (before.note_type() as usize, before.id()),
                ).is_ok());
                if !notes.is_empty() {
                    $crate::notes::NotesStorageEditHook::pre_update(&mut hooks, self, &mut notes);
                }
                $(let mut $field_name: ::std::vec::Vec<(u64, $variant_ty)> =
                    ::std::vec::Vec::new();)*
                for (id, note) in notes {
                    match note {
                        $($note_enum_name::$enum_variant(n) => $field_name.push((id, n)),)*
                    }
                }
                $(
                    if !$field_name.is_empty() {
                        self.$field_name.replace_notes(
                            &note_groups,
                            &tempo_tracks,
                            &scroll_tracks,
                            $field_name.into_iter());
                    }
                )*
                // Capture every after snapshot before post hooks can mutate storage.
                let updates: ::std::vec::Vec<_> = befores.into_iter().filter_map(|before| {
                    self.query_notes(::std::iter::once((before.id(), before.note_type())))
                        .next().map(|after| (before, after))
                }).collect();
                if !updates.is_empty() {
                    $crate::notes::NotesStorageEditHook::post_update(&mut hooks, self, &updates);
                }
            }
        }

        impl Default for $struct_name {
            fn default() -> Self {
                Self::new()
            }
        }
    };

    (@edit_hooks_tuple) => { () };

    (@edit_hooks_tuple $hook:expr) => { $hook };

    (@edit_hooks_tuple $first:expr, $($rest:expr),+) => {
        ($first, $crate::generate_notes_storage!(@edit_hooks_tuple $($rest),+))
    };
}

/// Timing and grouping shared by generated owned and borrowed note enums.
///
/// Implemented by [`generate_notes_storage!`] so generic [`NotesStorage`]
/// consumers can inspect notes.
pub trait Note {
    /// The note's musical start time.
    fn start_time(&self) -> crate::rhythm::Time;

    /// The note's musical duration (zero for short notes).
    fn duration(&self) -> crate::rhythm::Time;

    /// The group containing the note.
    fn group_id(&self) -> crate::notes::GroupId;
}

/// Storage identity and timing available on stored-note views and owned snapshots.
///
/// Implemented by [`generate_notes_storage!`] so generic [`NotesStorage`]
/// consumers can inspect notes.
pub trait NoteState: Note {
    /// Owned snapshot produced by this stored-note view.
    type Snapshot: NoteState<Snapshot = Self::Snapshot> + Clone;

    /// Capture the note value, runtime state, storage identity, and resolved timing.
    fn to_snapshot(&self) -> Self::Snapshot;

    /// The storage id, unique within the note's type.
    fn id(&self) -> u64;

    /// The note's time interval after conversion through its tempo track.
    fn clock_time_interval(&self) -> crate::notes::Interval<crate::rhythm::ClockTime>;
}

/// Represents storage for rhythm game notes.
///
/// # Remarks
/// Implemented automatically by [`generate_notes_storage!`].
///
/// This traits link to the relevant note enum and note state types, and defines edit operations,
/// so generic API can operate on user's generated notes storage.
pub trait NotesStorage {
    type NoteTypeEnum: Clone
        + Copy
        + Eq
        + for<'a> From<&'a Self::NoteEnum>
        + for<'a> From<&'a Self::NoteSnapshotEnum>
        + 'static;
    type NoteEnum: Note
        + Clone
        + for<'a> From<&'a Self::NoteSnapshotEnum>
        + for<'a, 'b> From<&'a Self::NoteRefEnum<'b>>
        + for<'a, 'b> From<&'a Self::NoteMutEnum<'b>>;
    type NoteSnapshotEnum: NoteState<Snapshot = Self::NoteSnapshotEnum> + Clone;
    type NoteRefEnum<'a>: NoteState<Snapshot = Self::NoteSnapshotEnum>
        + for<'b> From<&'a Self::NoteMutEnum<'b>>
    where
        Self: 'a;
    type NoteMutEnum<'a>: NoteState<Snapshot = Self::NoteSnapshotEnum>
    where
        Self: 'a;

    /// Rebuild the stored clock times after changes to tempo tracks.
    ///
    /// # Remarks
    /// Each note may be placed in either beat time or clock time, but are indexed by clock time.
    /// After changes to tempo events, the storage must recompute the note's clock time, scroll
    /// position and reindex.
    fn rebuild_clock_time<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
    );

    /// Rebuild the stored scroll position after changes to scroll tracks.
    ///
    /// # Remarks
    /// After changes to scroll speed change events, the storage must recompute the note's scroll
    /// position and reindex.
    fn rebuild_scroll_pos<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
    );

    /// Add a note to the storage, returning the id of the added note.
    fn add_note<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
        note: Self::NoteEnum,
    ) -> u64;

    /// Add multiple notes to the storage, returning the ids of the added notes.
    ///
    /// Returns a vec of the tuple (note id, note type) of all notes that were added,
    /// in the order they were declared in `notes`.
    fn add_notes<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
        notes: ::std::vec::Vec<Self::NoteEnum>,
    ) -> Vec<(u64, Self::NoteTypeEnum)>;

    /// Remove a note from the storage.
    fn remove_note(&mut self, note_type: Self::NoteTypeEnum, id: u64);

    /// Remove multiple notes from the storage.
    fn remove_notes(&mut self, notes: ::std::vec::Vec<(u64, Self::NoteTypeEnum)>);

    /// Iterate over every note, yielding cloned snapshot of each note.
    fn all_notes(&self) -> impl Iterator<Item = Self::NoteSnapshotEnum>;

    /// Iterate over every note of one note type.
    fn all_notes_of_type(
        &self,
        note_type: Self::NoteTypeEnum,
    ) -> impl Iterator<Item = Self::NoteSnapshotEnum>;

    /// Iterate over every note of one note type, yielding reference to the note.
    fn all_notes_ref_of_type<'a>(
        &'a self,
        note_type: Self::NoteTypeEnum,
    ) -> impl Iterator<Item = Self::NoteRefEnum<'a>> + 'a
    where
        Self: 'a;

    /// Visit every one note of a note type once, mutating each with a callback.
    fn all_notes_mut_of_type(
        &mut self,
        note_type: Self::NoteTypeEnum,
        f: impl FnMut(Self::NoteMutEnum<'_>),
    );

    /// Query for notes by their ids and note type, yielding cloned snapshot of each note.
    fn query_notes(
        &self,
        ids: impl Iterator<Item = (u64, Self::NoteTypeEnum)> + Clone,
    ) -> impl Iterator<Item = Self::NoteSnapshotEnum>;

    /// Query for notes by their ids and note type, yielding reference to each note.
    fn query_notes_ref<'a>(
        &'a self,
        ids: impl Iterator<Item = (u64, Self::NoteTypeEnum)> + Clone + 'a,
    ) -> impl Iterator<Item = Self::NoteRefEnum<'a>> + 'a
    where
        Self: 'a;

    /// Visit notes by note id and note type, mutating each with a callback.
    fn query_notes_mut(
        &mut self,
        ids: impl Iterator<Item = (u64, Self::NoteTypeEnum)> + Clone,
        f: impl FnMut(Self::NoteMutEnum<'_>),
    );

    /// Query for notes whose time overlaps a timing range, yielding cloned snapshot of each note.
    fn notes_overlapping_range(
        &self,
        range: crate::notes::Interval<crate::rhythm::ClockTime>,
    ) -> impl Iterator<Item = Self::NoteSnapshotEnum>;

    /// Query for notes whose time overlaps a timing range, yielding reference to each note.
    fn notes_ref_overlapping_range<'a>(
        &'a self,
        range: crate::notes::Interval<crate::rhythm::ClockTime>,
    ) -> impl Iterator<Item = Self::NoteRefEnum<'a>> + 'a
    where
        Self: 'a;

    /// Visit notes whose time overlaps a timing range, mutating each with a callback.
    fn notes_mut_overlapping_range(
        &mut self,
        range: crate::notes::Interval<crate::rhythm::ClockTime>,
        f: impl FnMut(Self::NoteMutEnum<'_>),
    );

    /// Access notes from the storage with a callback while deleting them from the storage.
    fn extract_notes(
        &mut self,
        notes: ::std::vec::Vec<(u64, Self::NoteTypeEnum)>,
        f: impl FnMut(Self::NoteSnapshotEnum),
    );

    /// Replace a note identified by an id and note type with new note value.
    fn replace_note<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
        id: u64,
        note: Self::NoteEnum,
    );

    /// Replace multiple notes identified by ids and note types with new note value.
    fn replace_notes<G: crate::notes::NoteGroup>(
        &mut self,
        note_groups: &crate::notes::NoteGroups<G>,
        tempo_tracks: &crate::rhythm::TempoTracks,
        scroll_tracks: &crate::rhythm::ScrollSpeedTracks,
        notes: ::std::vec::Vec<(u64, Self::NoteEnum)>,
    );
}

/// Edit hooks for a notes storage generated by [`generate_notes_storage!`].
///
/// A hook type is registered with the `edit_hook` entry of [`generate_notes_storage!`], and may
/// implement any subset of the methods (unimplemented methods default to no-ops).
///
/// Hooks are not stored permanently, but are instantiated once per notes storage edit
/// call. The same instance receives all pre and post callbacks in that call, allowing allocations
/// to be reused across a batch edit. Instances are dropped when the call finishes.
///
/// Hooks fire around notes storage edit operations ([`NotesStorage::add_note`],
/// [`NotesStorage::remove_note`], etc.) and notes storage construction. When multiple hooks are
/// registered, they run in declaration order, each receiving the entire batch before
/// the next hook runs. Single-note edits receive one-element slices. Empty batches,
/// including edits with no existing targets, do not invoke callbacks.
///
/// For bulk edit methods, all pre hooks run before storage applies the batch, and all post
/// hooks run after the whole batch is applied. Add pre hooks follow input order; add post
/// hooks and removal hooks follow note type declaration order. Within each type, removals
/// follow id order. Update hooks follow note type declaration order, then id order.
/// Duplicate (note type, id) pairs are deduplicated, and missing notes do not trigger hooks.
///
/// Hooks receive `&mut S` and may perform further edits reentrantly, each nested edit fires
/// its own fresh hook instances (but be careful of infinite recursion).
#[allow(unused_variables)]
pub trait NotesStorageEditHook<S: NotesStorage> {
    /// Called after [`NotesStorage::rebuild_clock_time`].
    fn post_rebuild_clock_time(&mut self, storage: &mut S) {}

    /// Called after [`NotesStorage::rebuild_scroll_pos`].
    fn post_rebuild_scroll_pos(&mut self, storage: &mut S) {}

    /// Called before notes are added.
    ///
    /// `notes` may be modified; the modified values are stored.
    fn pre_add(&mut self, storage: &mut S, notes: &mut [S::NoteEnum]) {}

    /// Called after addition, with each assigned id and its note type.
    fn post_add(&mut self, storage: &mut S, notes: &[(u64, S::NoteTypeEnum)]) {}

    /// Called before removal, borrowing snapshots captured before all pre-remove hooks.
    fn pre_remove(&mut self, storage: &mut S, notes: &[S::NoteSnapshotEnum]) {}

    /// Called after removal, with the value, runtime state, and resolved timing captured before pre-remove hooks.
    fn post_remove(&mut self, storage: &mut S, notes: &[S::NoteSnapshotEnum]) {}

    /// Called before replacement.
    ///
    /// Modify the new values only; preserve ids and note types.
    fn pre_update(&mut self, storage: &mut S, notes: &mut [(u64, S::NoteEnum)]) {}

    /// Called after replacement, with snapshots captured before pre-update hooks and after storage updates.
    fn post_update(
        &mut self,
        storage: &mut S,
        notes: &[(S::NoteSnapshotEnum, S::NoteSnapshotEnum)],
    ) {
    }
}

// Recursive tuples preserve static dispatch and declaration order without allocating.
impl<S: NotesStorage> NotesStorageEditHook<S> for () {}

impl<S: NotesStorage, H: NotesStorageEditHook<S>, T: NotesStorageEditHook<S>>
    NotesStorageEditHook<S> for (H, T)
{
    fn post_rebuild_clock_time(&mut self, storage: &mut S) {
        self.0.post_rebuild_clock_time(storage);
        self.1.post_rebuild_clock_time(storage);
    }

    fn post_rebuild_scroll_pos(&mut self, storage: &mut S) {
        self.0.post_rebuild_scroll_pos(storage);
        self.1.post_rebuild_scroll_pos(storage);
    }

    fn pre_add(&mut self, storage: &mut S, notes: &mut [S::NoteEnum]) {
        self.0.pre_add(storage, notes);
        self.1.pre_add(storage, notes);
    }

    fn post_add(&mut self, storage: &mut S, notes: &[(u64, S::NoteTypeEnum)]) {
        self.0.post_add(storage, notes);
        self.1.post_add(storage, notes);
    }

    fn pre_remove(&mut self, storage: &mut S, notes: &[S::NoteSnapshotEnum]) {
        self.0.pre_remove(storage, notes);
        self.1.pre_remove(storage, notes);
    }

    fn post_remove(&mut self, storage: &mut S, notes: &[S::NoteSnapshotEnum]) {
        self.0.post_remove(storage, notes);
        self.1.post_remove(storage, notes);
    }

    fn pre_update(&mut self, storage: &mut S, notes: &mut [(u64, S::NoteEnum)]) {
        self.0.pre_update(storage, notes);
        self.1.pre_update(storage, notes);
    }

    fn post_update(
        &mut self,
        storage: &mut S,
        notes: &[(S::NoteSnapshotEnum, S::NoteSnapshotEnum)],
    ) {
        self.0.post_update(storage, notes);
        self.1.post_update(storage, notes);
    }
}