Enum RevsetExpression

pub enum RevsetExpression<St: ExpressionState> {
    None,
    All,
    VisibleHeads,
    VisibleHeadsOrReferenced,
    Root,
    Commits(Vec<CommitId>),
    CommitRef(St::CommitRef),
    Ancestors {
        heads: Rc<Self>,
        generation: Range<u64>,
    },
    Descendants {
        roots: Rc<Self>,
        generation: Range<u64>,
    },
    Range {
        roots: Rc<Self>,
        heads: Rc<Self>,
        generation: Range<u64>,
    },
    DagRange {
        roots: Rc<Self>,
        heads: Rc<Self>,
    },
    Reachable {
        sources: Rc<Self>,
        domain: Rc<Self>,
    },
    Heads(Rc<Self>),
    HeadsRange {
        roots: Rc<Self>,
        heads: Rc<Self>,
        filter: Rc<Self>,
    },
    Roots(Rc<Self>),
    ForkPoint(Rc<Self>),
    Latest {
        candidates: Rc<Self>,
        count: usize,
    },
    Filter(RevsetFilterPredicate),
    AsFilter(Rc<Self>),
    AtOperation {
        operation: St::Operation,
        candidates: Rc<Self>,
    },
    WithinReference {
        candidates: Rc<Self>,
        commits: Vec<CommitId>,
    },
    WithinVisibility {
        candidates: Rc<Self>,
        visible_heads: Vec<CommitId>,
    },
    Coalesce(Rc<Self>, Rc<Self>),
    Present(Rc<Self>),
    NotIn(Rc<Self>),
    Union(Rc<Self>, Rc<Self>),
    Intersection(Rc<Self>, Rc<Self>),
    Difference(Rc<Self>, Rc<Self>),
}

Tree of revset expressions describing DAG operations.

Use UserRevsetExpression or ResolvedRevsetExpression to construct expression of that state.

Variants

None

All

VisibleHeads

VisibleHeadsOrReferenced

Visible heads and all referenced commits within the current expression scope. Used as the default of Range/DagRange heads.

Root

Commits(Vec<CommitId>)

CommitRef(St::CommitRef)

Ancestors

Fields

heads: Rc<Self>

generation: Range<u64>

Descendants

Fields

roots: Rc<Self>

generation: Range<u64>

Range

Fields

roots: Rc<Self>

heads: Rc<Self>

generation: Range<u64>

DagRange

Fields

roots: Rc<Self>

heads: Rc<Self>

Reachable

Fields

sources: Rc<Self>

domain: Rc<Self>

Heads(Rc<Self>)

HeadsRange

Heads of the set of commits which are ancestors of heads but are not ancestors of roots, and which also are contained in filter.

Fields

roots: Rc<Self>

heads: Rc<Self>

filter: Rc<Self>

Roots(Rc<Self>)

ForkPoint(Rc<Self>)

Latest

Fields

candidates: Rc<Self>

count: usize

Filter(RevsetFilterPredicate)

AsFilter(Rc<Self>)

Marker for subtree that should be intersected as filter.

AtOperation

Resolves symbols and visibility at the specified operation.

Fields

operation: St::Operation

candidates: Rc<Self>

WithinReference

Makes All include the commits and their ancestors in addition to the visible heads.

Fields

candidates: Rc<Self>

commits: Vec<CommitId>

Commits explicitly referenced within the scope.

WithinVisibility

Resolves visibility within the specified repo state.

Fields

candidates: Rc<Self>

visible_heads: Vec<CommitId>

Copy of repo.view().heads() at the operation.

Coalesce(Rc<Self>, Rc<Self>)

Present(Rc<Self>)

NotIn(Rc<Self>)

Union(Rc<Self>, Rc<Self>)

Intersection(Rc<Self>, Rc<Self>)

Difference(Rc<Self>, Rc<Self>)

Implementations

impl<St: ExpressionState> RevsetExpression<St>

pub fn none() -> Rc<Self>

pub fn all() -> Rc<Self>

Ancestors of visible heads and all referenced commits within the current expression scope, which may include hidden commits.

pub fn visible_heads() -> Rc<Self>

pub fn root() -> Rc<Self>

pub fn commit(commit_id: CommitId) -> Rc<Self>

pub fn commits(commit_ids: Vec<CommitId>) -> Rc<Self>

pub fn filter(predicate: RevsetFilterPredicate) -> Rc<Self>

pub fn is_empty() -> Rc<Self>

Find any empty commits.

impl<St: ExpressionState<CommitRef = RevsetCommitRef>> RevsetExpression<St>

pub fn working_copy(name: WorkspaceNameBuf) -> Rc<Self>

pub fn working_copies() -> Rc<Self>

pub fn symbol(value: String) -> Rc<Self>

pub fn remote_symbol(value: RemoteRefSymbolBuf) -> Rc<Self>

pub fn change_id_prefix(prefix: HexPrefix) -> Rc<Self>

pub fn commit_id_prefix(prefix: HexPrefix) -> Rc<Self>

pub fn bookmarks(pattern: StringPattern) -> Rc<Self>

pub fn remote_bookmarks( bookmark_pattern: StringPattern, remote_pattern: StringPattern, remote_ref_state: Option<RemoteRefState>, ) -> Rc<Self>

pub fn tags(pattern: StringPattern) -> Rc<Self>

pub fn git_refs() -> Rc<Self>

pub fn git_head() -> Rc<Self>

impl<St: ExpressionState> RevsetExpression<St>

pub fn latest(self: &Rc<Self>, count: usize) -> Rc<Self>

pub fn heads(self: &Rc<Self>) -> Rc<Self>

Commits in self that don’t have descendants in self.

pub fn roots(self: &Rc<Self>) -> Rc<Self>

Commits in self that don’t have ancestors in self.

pub fn parents(self: &Rc<Self>) -> Rc<Self>

Parents of self.

pub fn ancestors(self: &Rc<Self>) -> Rc<Self>

Ancestors of self, including self.

pub fn ancestors_at(self: &Rc<Self>, generation: u64) -> Rc<Self>

Ancestors of self at an offset of generation behind self. The generation offset is zero-based starting from self.

pub fn ancestors_range( self: &Rc<Self>, generation_range: Range<u64>, ) -> Rc<Self>

Ancestors of self in the given range.

pub fn children(self: &Rc<Self>) -> Rc<Self>

Children of self.

pub fn descendants(self: &Rc<Self>) -> Rc<Self>

Descendants of self, including self.

pub fn descendants_at(self: &Rc<Self>, generation: u64) -> Rc<Self>

Descendants of self at an offset of generation ahead of self. The generation offset is zero-based starting from self.

pub fn descendants_range( self: &Rc<Self>, generation_range: Range<u64>, ) -> Rc<Self>

Descendants of self in the given range.

pub fn fork_point(self: &Rc<Self>) -> Rc<Self>

Fork point (best common ancestors) of self.

pub fn filtered(self: &Rc<Self>, predicate: RevsetFilterPredicate) -> Rc<Self>

Filter all commits by predicate in self.

pub fn dag_range_to(self: &Rc<Self>, heads: &Rc<Self>) -> Rc<Self>

Commits that are descendants of self and ancestors of heads, both inclusive.

pub fn connected(self: &Rc<Self>) -> Rc<Self>

Connects any ancestors and descendants in the set by adding the commits between them.

pub fn reachable(self: &Rc<Self>, domain: &Rc<Self>) -> Rc<Self>

All commits within domain reachable from this set of commits, by traversing either parent or child edges.

pub fn range(self: &Rc<Self>, heads: &Rc<Self>) -> Rc<Self>

Commits reachable from heads but not from self.

pub fn present(self: &Rc<Self>) -> Rc<Self>

Suppresses name resolution error within self.

pub fn negated(self: &Rc<Self>) -> Rc<Self>

Commits that are not in self, i.e. the complement of self.

pub fn union(self: &Rc<Self>, other: &Rc<Self>) -> Rc<Self>

Commits that are in self or in other (or both).

pub fn union_all(expressions: &[Rc<Self>]) -> Rc<Self>

Commits that are in any of the expressions.

pub fn intersection(self: &Rc<Self>, other: &Rc<Self>) -> Rc<Self>

Commits that are in self and in other.

pub fn minus(self: &Rc<Self>, other: &Rc<Self>) -> Rc<Self>

Commits that are in self but not in other.

pub fn coalesce(expressions: &[Rc<Self>]) -> Rc<Self>

Commits that are in the first expression in expressions that is not none().

impl<St: ExpressionState<CommitRef = RevsetCommitRef>> RevsetExpression<St>

pub fn as_symbol(&self) -> Option<&str>

Returns symbol string if this expression is of that type.

impl RevsetExpression<UserExpressionState>

pub fn resolve_user_expression( &self, repo: &dyn Repo, symbol_resolver: &SymbolResolver<'_>, ) -> Result<Rc<ResolvedRevsetExpression>, RevsetResolutionError>

Resolve a user-provided expression. Symbols will be resolved using the provided SymbolResolver.

impl RevsetExpression<ResolvedExpressionState>

pub fn evaluate<'index>( self: Rc<Self>, repo: &'index dyn Repo, ) -> Result<Box<dyn Revset + 'index>, RevsetEvaluationError>

Optimizes and evaluates this expression.

pub fn evaluate_unoptimized<'index>( self: &Rc<Self>, repo: &'index dyn Repo, ) -> Result<Box<dyn Revset + 'index>, RevsetEvaluationError>

Evaluates this expression without optimizing it.

Use this function if self is already optimized, or to debug optimization pass.

pub fn to_backend_expression(&self, repo: &dyn Repo) -> ResolvedExpression

Transforms this expression to the form which the Index backend will process.

Trait Implementations

impl<St: Clone + ExpressionState> Clone for RevsetExpression<St>

where St::CommitRef: Clone, St::Operation: Clone,

fn clone(&self) -> RevsetExpression<St>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<St: Debug + ExpressionState> Debug for RevsetExpression<St>

where St::CommitRef: Debug, St::Operation: Debug,

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

Formats the value using the given formatter.