Enum RevsetExpression

pub enum RevsetExpression<St: ExpressionState> {
    None,
    All,
    VisibleHeads,
    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>),
    Roots(Rc<Self>),
    ForkPoint(Rc<Self>),
    Latest {
        candidates: Rc<Self>,
        count: usize,
    },
    Filter(RevsetFilterPredicate),
    AsFilter(Rc<Self>),
    AtOperation {
        operation: St::Operation,
        candidates: Rc<Self>,
    },
    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

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>)

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>

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>

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 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: &dyn 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, 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 copy of the value.

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.