pipecircuit 0.0.25

Correct. Robust. Fast. Portable. Pick four.
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

use super::super::{BulkSelection, BulkUpdateError, BulkUpdateWorkspace, WarpTableRow};
use super::{CallerQuery, CallerSelection, CallerStorage, CallerWarpTable, CallerWarpTableColumns};
use crate::storage::query_workspace::{
    QueryChunkStorage, QueryScratchStorage, QueryWorkspaceError,
};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CallerBulkUpdateError<Selection> {
    QueryStorage(QueryWorkspaceError),
    Selection(Selection),
    DifferentTables,
    Update(BulkUpdateError),
}

#[doc(hidden)]
pub trait CallerWarpTableBulkUpdate<Row: WarpTableRow, Update, Output>:
    CallerWarpTableColumns<Row>
{
    fn bulk_update(
        &mut self,
        indexes: &mut Self::Indexes,
        selection: BulkSelection<'_>,
        update: Update,
    ) -> Result<Output, BulkUpdateError>;
}

impl<'storage, Row: WarpTableRow, Columns: CallerWarpTableColumns<Row>, Brand>
    CallerWarpTable<'storage, Row, Columns, Brand>
{
    pub fn bulk_update_in<Chunks, Scratch, Pending, Group, Slots, Update, Output, Error>(
        &mut self,
        workspace: &mut BulkUpdateWorkspace<Chunks, Scratch, Pending, Group, Slots>,
        select: impl for<'table, 'workspace> FnOnce(
            CallerQuery<'table, 'workspace, Row, Brand, CallerStorage<'storage, Row, Columns>>,
        ) -> Result<
            CallerSelection<'table, 'workspace, Row, Brand, CallerStorage<'storage, Row, Columns>>,
            Error,
        >,
        update: Update,
    ) -> Result<Output, CallerBulkUpdateError<Error>>
    where
        Chunks: QueryChunkStorage,
        Scratch: QueryScratchStorage,
        Pending: QueryScratchStorage,
        Group: QueryScratchStorage,
        Slots: AsMut<[u16]>,
        Columns: CallerWarpTableBulkUpdate<Row, Update, Output>,
    {
        let selected = select(
            self.query_in(
                workspace
                    .query
                    .membership()
                    .map_err(CallerBulkUpdateError::QueryStorage)?,
            ),
        )
        .map_err(CallerBulkUpdateError::Selection)?;
        if !core::ptr::eq(self, selected.table) {
            return Err(CallerBulkUpdateError::DifferentTables);
        }
        let membership = selected.into_workspace();
        Columns::bulk_update(
            &mut self.columns,
            &mut self.indexes,
            BulkSelection {
                selected: &membership,
                pending: workspace.pending.as_mut(),
                group: workspace.group.as_mut(),
                slots: workspace.slots.as_mut(),
            },
            update,
        )
        .map_err(CallerBulkUpdateError::Update)
    }
}