Struct RepositorySet 

pub struct RepositorySet { /* private fields */ }

Implementations

impl RepositorySet

pub fn open<I, S, P>(repositories: I) -> Result<Self>

where I: IntoIterator<Item = (S, P)>, S: Into<String>, P: AsRef<Path>,

Examples found in repository

examples/benchmark_cross_repo.rs (lines 85-90)

fn open(paths: &[String]) -> weavatrix_git::Result<RepositorySet> {
    RepositorySet::open(
        paths
            .iter()
            .enumerate()
            .map(|(index, path)| (format!("r{index}"), path)),
    )
}

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn id(&self, name: &str) -> Option<RepositoryId>

pub fn name(&self, id: RepositoryId) -> Option<&str>

pub fn repository(&self, id: RepositoryId) -> Option<&Repository>

pub fn resolve(&self, id: RepositoryId, revision: &str) -> Result<ObjectId>

pub fn find_object(&self, id: ObjectId) -> Vec<RepositoryId>

pub fn histories( &self, options: HistoryOptions, ) -> Result<Vec<RepositoryHistory>>

Examples found in repository

examples/benchmark_cross_repo.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = env::args().skip(1).collect::<Vec<_>>();
    if args.len() < 3 {
        return Err("usage: benchmark_cross_repo <max-count> <iterations> <repo>...".into());
    }
    let max_count = args[0].parse()?;
    let iterations = args[1].parse()?;
    let paths = &args[2..];
    let options = HistoryOptions {
        max_commits: max_count,
        first_parent: true,
        ..HistoryOptions::default()
    };
    let set = open(paths)?;
    let expected = git_histories(paths, max_count)?;
    let actual = set.histories_parallel(options)?;
    for (history, expected) in actual.iter().zip(&expected) {
        let actual = history
            .commits
            .iter()
            .map(ToString::to_string)
            .collect::<Vec<_>>();
        if actual != *expected {
            return Err("cross-repository history differs from git rev-list".into());
        }
    }

    let serial = measure(iterations, || {
        set.histories(options).map(|items| item_count(&items))
    })?;
    let parallel = measure(iterations, || {
        set.histories_parallel(options)
            .map(|items| item_count(&items))
    })?;
    let reopen = measure(iterations, || {
        open(paths)?
            .histories_parallel(options)
            .map(|items| item_count(&items))
    })?;
    let git = measure(iterations, || {
        git_histories(paths, max_count).map(|items| items.iter().map(Vec::len).sum::<usize>())
    })?;
    println!("engine,mode,p50_ms,p95_ms,repositories,commits");
    print_row(
        "weavatrix-git",
        "serial",
        &serial,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "weavatrix-git",
        "parallel",
        &parallel,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "weavatrix-git",
        "reopen-parallel",
        &reopen,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "git.exe",
        "sequential-processes",
        &git,
        paths.len(),
        item_count(&actual),
    );
    Ok(())
}

pub fn histories_parallel( &self, options: HistoryOptions, ) -> Result<Vec<RepositoryHistory>>

Examples found in repository

examples/benchmark_cross_repo.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = env::args().skip(1).collect::<Vec<_>>();
    if args.len() < 3 {
        return Err("usage: benchmark_cross_repo <max-count> <iterations> <repo>...".into());
    }
    let max_count = args[0].parse()?;
    let iterations = args[1].parse()?;
    let paths = &args[2..];
    let options = HistoryOptions {
        max_commits: max_count,
        first_parent: true,
        ..HistoryOptions::default()
    };
    let set = open(paths)?;
    let expected = git_histories(paths, max_count)?;
    let actual = set.histories_parallel(options)?;
    for (history, expected) in actual.iter().zip(&expected) {
        let actual = history
            .commits
            .iter()
            .map(ToString::to_string)
            .collect::<Vec<_>>();
        if actual != *expected {
            return Err("cross-repository history differs from git rev-list".into());
        }
    }

    let serial = measure(iterations, || {
        set.histories(options).map(|items| item_count(&items))
    })?;
    let parallel = measure(iterations, || {
        set.histories_parallel(options)
            .map(|items| item_count(&items))
    })?;
    let reopen = measure(iterations, || {
        open(paths)?
            .histories_parallel(options)
            .map(|items| item_count(&items))
    })?;
    let git = measure(iterations, || {
        git_histories(paths, max_count).map(|items| items.iter().map(Vec::len).sum::<usize>())
    })?;
    println!("engine,mode,p50_ms,p95_ms,repositories,commits");
    print_row(
        "weavatrix-git",
        "serial",
        &serial,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "weavatrix-git",
        "parallel",
        &parallel,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "weavatrix-git",
        "reopen-parallel",
        &reopen,
        paths.len(),
        item_count(&actual),
    );
    print_row(
        "git.exe",
        "sequential-processes",
        &git,
        paths.len(),
        item_count(&actual),
    );
    Ok(())
}

pub fn shared_commits( &self, options: HistoryOptions, ) -> Result<Vec<SharedCommit>>

pub fn diff_commits( &self, old_repository: RepositoryId, old_revision: &str, new_repository: RepositoryId, new_revision: &str, ) -> Result<Vec<TreeChange>>