Struct branchless::git::Dag

pub struct Dag {
    pub head_commit: CommitSet,
    pub main_branch_commit: CommitSet,
    pub branch_commits: CommitSet,
    pub observed_commits: CommitSet,
    pub obsolete_commits: CommitSet,
    // some fields omitted
}

Interface to access the directed acyclic graph (DAG) representing Git’s commit graph. Based on the Eden SCM DAG.

Fields

head_commit: CommitSet

A set containing the commit which HEAD points to. If HEAD is unborn, this is an empty set.

main_branch_commit: CommitSet

A set containing the commit that the main branch currently points to.

branch_commits: CommitSet

A set containing all commits currently pointed to by local branches.

observed_commits: CommitSet

A set containing all commits that have been observed by the EventReplayer.

obsolete_commits: CommitSet

A set containing all commits that have been determined to be obsolete by the EventReplayer.

Implementations

impl Dag

pub fn open_and_sync(
    effects: &Effects,
    repo: &Repo,
    event_replayer: &EventReplayer,
    event_cursor: EventCursor,
    references_snapshot: &RepoReferencesSnapshot
) -> Result<Self>

Initialize the DAG for the given repository, and update it with any newly-referenced commits.

pub fn open_without_syncing(
    effects: &Effects,
    repo: &Repo,
    event_replayer: &EventReplayer,
    event_cursor: EventCursor,
    references_snapshot: &RepoReferencesSnapshot
) -> Result<Self>

Initialize a DAG for the given repository, without updating it with new commits that may have appeared.

If used improperly, commit lookups could fail at runtime. This function should only be used for opening the DAG when it’s known that no more live commits have appeared.

pub fn sync_from_oids(
    &mut self,
    effects: &Effects,
    repo: &Repo,
    master_heads: CommitSet,
    non_master_heads: CommitSet
) -> Result<()>

Update the DAG with the given heads.

pub fn set_cursor(
    &self,
    effects: &Effects,
    repo: &Repo,
    event_replayer: &EventReplayer,
    event_cursor: EventCursor
) -> Result<Self>

Create a new version of this DAG at the point in time represented by event_cursor.

pub fn get_one_merge_base_oid(
    &self,
    effects: &Effects,
    repo: &Repo,
    lhs_oid: NonZeroOid,
    rhs_oid: NonZeroOid
) -> Result<Option<NonZeroOid>>

Get one of the merge-base OIDs for the given pair of OIDs. If there are multiple possible merge-bases, one is arbitrarily returned.

pub fn get_range(
    &self,
    effects: &Effects,
    repo: &Repo,
    parent_oid: NonZeroOid,
    child_oid: NonZeroOid
) -> Result<Vec<NonZeroOid>>

Get the range of OIDs from parent_oid to child_oid. Note that there may be more than one path; in that case, the OIDs are returned in a topologically-sorted order.

pub fn query(&self) -> &Dag

Conduct an arbitrary query against the DAG.

pub fn query_public_commits(&self) -> Result<CommitSet>

Return the set of commits which are public (checked into the main branch).

pub fn query_active_heads(
    &self,
    public_commits: &CommitSet,
    observed_commits: &CommitSet
) -> Result<CommitSet>

Query the set of active heads. This includes the heads of the set of visible commits, plus any other commits which would be rendered in the smartlog.

This query includes heads which may be ancestor of other commits in the set. For example, if HEAD points to a commit which is the ancestor of a visible commit, both commits are included in the resulting set. This is so that they can be explicitly rendered in the smartlog. To get the set of visible commits, simply query for the ancestors of the set resulting from this function.

pub fn find_path_to_merge_base<'repo>(
    &self,
    effects: &Effects,
    repo: &'repo Repo,
    commit_oid: NonZeroOid,
    target_oid: NonZeroOid
) -> Result<Option<Vec<Commit<'repo>>>>

Find a shortest path between the given commits.

This is particularly important for multi-parent commits (i.e. merge commits). If we don’t happen to traverse the correct parent, we may end up traversing a huge amount of commit history, with a significant performance hit.

Args:

• repo: The Git repository.
• commit_oid: The OID of the commit to start at. We take parents of the provided commit until we end up at the target OID.
• target_oid: The OID of the commit to end at.

Returns: A path of commits from commit_oid through parents to target_oid. The path includes commit_oid at the beginning and target_oid at the end. If there is no such path, returns None.

pub fn find_path_to_main_branch(
    &self,
    effects: &Effects,
    head: CommitSet
) -> Result<Option<CommitSet>>

Find a path from the provided head to its merge-base with the main branch.

Trait Implementations

impl Debug for Dag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.