Function fold_transactions_internal

crates/commitlog/src/commitlog.rs:618–688

(
    mut commits: CommitsWithVersion<R>,
    de: D,
    range: impl RangeBounds<u64>,
)

}

fn fold_transactions_internal<R, D>(
    mut commits: CommitsWithVersion<R>,
    de: D,
    range: impl RangeBounds<u64>,
) -> Result<(), D::Error>
where
    R: Repo,
    D: Decoder,
    D::Error: From<error::Traversal>,
{
    use std::ops::Bound::*;

    // Avoid reading the first commit if it wouldn't be in the range anyway.
    if range_is_empty(&range) {
        return Ok(());
    }

    // `true` if `offset` is outside `range`, s.t. it is smaller than the start
    // bound.
    let before_start = |offset: &u64| match range.start_bound() {
        Included(x) => offset < x,
        Excluded(x) => offset <= x,
        Unbounded => false,
    };
    // `true` if `offset` is outside `range`, s.t. it is greater than the end
    // bound.
    let past_end = |offset: &u64| match range.end_bound() {
        Included(x) => offset > x,
        Excluded(x) => offset >= x,
        Unbounded => false,
    };

    while let Some(commit) = commits.next() {
        let (version, commit) = match commit {
            Ok(version_and_commit) => version_and_commit,
            Err(e) => {
                // Ignore it if the very last commit in the log is broken.
                // The next `append` will fix the log, but the `decoder`
                // has no way to tell whether we're at the end or not.
                // This is unlike the consumer of an iterator, which can
                // perform below check itself.
                if commits.next().is_none() {
                    return Ok(());
                }

                return Err(e.into());
            }
        };
        trace!("commit {} n={} version={}", commit.min_tx_offset, commit.n, version);

        let max_tx_offset = commit.min_tx_offset + commit.n as u64;
        // Skip if no transaction in the commit is in range.
        if before_start(&max_tx_offset) {
            continue;
        }

        let records = &mut commit.records.as_slice();
        for n in 0..commit.n {