Enum RequestError 

#[non_exhaustive]
pub enum RequestError {
    InvalidValue {
        axis: &'static str,
        value: String,
        expected: String,
    },
    #[non_exhaustive]
    AnalyzerNamedAsView {
        value: String,
        analyzer: &'static str,
        suggested_view: ViewSpec,
    },
    #[non_exhaustive]
    ViewNeedsAnalyzer {
        view: ViewSpec,
        held: AnalysisSet,
        holder: BasisHolder,
    },
    #[non_exhaustive]
    SortNeedsAnalyzer {
        metric: &'static str,
        analyzer: AnalysisSet,
        held: AnalysisSet,
        holder: BasisHolder,
    },
    IgnoredWithoutObservation(IgnoredEntries),
    PopulationMismatch {
        held: IgnoredEntries,
        requested: IgnoredEntries,
    },
    ScopeUnsupported {
        axis: ScopeAxis,
        reason: &'static str,
    },
    ContentMismatch {
        held: AnalysisSet,
        requested: AnalysisSet,
    },
    WatchScope,
    #[non_exhaustive]
    WatchContent {
        named: AnalysisSet,
        views: Vec<ViewSpec>,
    },
    WatchCacheOnly,
    StaleOkCacheOff,
    RootMismatch {
        held: PathBuf,
        requested: PathBuf,
    },
    DeliveryUnsupported {
        route: &'static str,
        reason: &'static str,
    },
    ViewLimit {
        attempted: usize,
        limit: usize,
    },
}

Why a request cannot be answered as asked.

Typed so a caller can match the refusal it can act on, and rendered by Self::message in the vocabulary of the surface the request came through.

Non-exhaustive, so a later refusal is an additive change: a match outside this crate names the refusals it acts on and renders the rest with Self::message. Self::AnalyzerNamedAsView, Self::ViewNeedsAnalyzer, Self::SortNeedsAnalyzer, and Self::WatchContent are non-exhaustive too, so a field one of them gains later is additive as well: a match outside this crate reads them with ...

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InvalidValue

A value did not match its axis’s grammar.

Fields

axis: &'static str

The axis, as the requesting surface names it.

value: String

The rejected value, as the grammar quotes it.

expected: String

What the grammar accepts instead.

#[non_exhaustive]

AnalyzerNamedAsView

An analyzer name was supplied where a report view was expected.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

value: String

The rejected token in the caller’s spelling.

analyzer: &'static str

The analyzer the token names.

suggested_view: ViewSpec

The view that shows that analyzer’s results.

#[non_exhaustive]

ViewNeedsAnalyzer

A view shows analysis the basis does not hold.

Only a basis the request did not build can raise this – a retained index, an opened root, or one supplied whole – because Request::build enables what its views imply, and a read never widens what a holder was opened with.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

view: ViewSpec

The view the read named.

held: AnalysisSet

The analyzers the basis holds.

holder: BasisHolder

What fixed those analyzers, which decides the remedy the refusal names.

#[non_exhaustive]

SortNeedsAnalyzer

A sort by a content metric whose analyzer the request did not enable.

Unlike a content view, a sort implies nothing: it orders rows and never says what a report is about, so the analyzer must be named.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

metric: &'static str

The metric, as the sort axis spells it.

analyzer: AnalysisSet

The analyzers that measure it.

held: AnalysisSet

The analyzers the basis holds.

holder: BasisHolder

What fixed those analyzers, which decides the remedy the refusal names.

IgnoredWithoutObservation(IgnoredEntries)

A selection by ignored state over a scan that observes no .gitignore.

PopulationMismatch

A retained narrow population cannot answer a read of another population.

Fields

held: IgnoredEntries

Population retained by the holder.

requested: IgnoredEntries

Population this read selected.

ScopeUnsupported

A scan scope this build cannot honour, whatever the delivery.

Fields

axis: ScopeAxis

Which axis, so each surface names it in its own words.

reason: &'static str

The rule, one sentence, in the library’s field names.

ContentMismatch

A read asks for another analyzer set than the retained index holds.

Fields

held: AnalysisSet

The analyzers the index was built with.

requested: AnalysisSet

The analyzers the read asks for.

WatchScope

A watch was asked to narrow its scan scope.

#[non_exhaustive]

WatchContent

A watch was asked to keep content analysis current.

Names every axis that enabled analysis, so a caller who drops one is not refused again for the other.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

named: AnalysisSet

The analyzers the caller named, or that a basis supplied whole holds; none when every analyzer was implied by a view.

views: Vec<ViewSpec>

The views that implied analysis, in the caller’s order; empty when none did.

WatchCacheOnly

A watch was asked to start from a snapshot nothing verifies.

StaleOkCacheOff

A stale answer was asked of a delivery that never reads the snapshot.

RootMismatch

An operation names another root than the retained index it would mutate.

Fields

held: PathBuf

Root held by the index.

requested: PathBuf

Root requested by the caller.

DeliveryUnsupported

A route cannot honor the requested execution policy.

Fields

route: &'static str

The lifecycle that refuses it.

reason: &'static str

The unsupported policy combination.

ViewLimit

A read names more views than one report may carry.

Fields

attempted: usize

Views and omitted views the request carries.

limit: usize

The most one report accepts.

Implementations

impl RequestError

pub fn message(&self, axes: &AxisNames) -> String

The refusal in the vocabulary of the surface axes describes.

Self::InvalidValue already carries its axis, named by the surface that parsed it, so axes names only the knobs the other refusals point at.

Trait Implementations

impl Clone for RequestError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestError

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

Formats the value using the given formatter.

impl Display for RequestError

The library’s vocabulary, as AxisNames::default is: a refusal rendered without naming a surface belongs to a library caller, not to the command line.

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

Formats the value using the given formatter.

impl Eq for RequestError

impl Error for RequestError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for RequestError

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RequestError