Enum PlanError 

#[non_exhaustive]
pub enum PlanError {
    MissingEntryNode,
    DuplicateNodeId {
        node: NodeId,
    },
    UndefinedNode {
        node: NodeId,
    },
    MissingTransition {
        node: NodeId,
    },
    AmbiguousTransition {
        node: NodeId,
        first: ExitPattern,
        second: ExitPattern,
    },
    UnreachableNode {
        node: NodeId,
    },
    CyclicGraph {
        node: NodeId,
    },
    TooManyNodes {
        max: usize,
    },
    TooManyTransitions {
        max: usize,
    },
    TooManyOutgoingTransitions {
        node: NodeId,
        max: usize,
    },
    InvalidPattern {
        max_bytes: usize,
    },
    ZeroDecisionInputVersion,
    InvalidSplitBranchCount {
        split: NodeId,
        min: usize,
        max: usize,
    },
    InvalidBranchLength {
        split: NodeId,
        max: usize,
    },
    SplitIsEntry {
        split: NodeId,
    },
    InvalidSplitJoin {
        split: NodeId,
        join: NodeId,
    },
    JoinHasMultipleOwners {
        join: NodeId,
        first: NodeId,
        second: NodeId,
    },
    OrphanJoin {
        join: NodeId,
    },
    JoinHasExternalEntry {
        join: NodeId,
    },
    SplitHasExplicitTransition {
        split: NodeId,
    },
    ParallelBudgetExceedsBranches {
        split: NodeId,
        branches: usize,
    },
    InvalidParallelBranchBudget {
        max: usize,
    },
    InvalidPartitionWorkerBudget {
        max: u8,
    },
    InsufficientPoolCapacity {
        required: u32,
        configured: u32,
    },
    InvalidPartitionCount {
        max: u16,
    },
    Token(DefinitionError),
    Manifest(DefinitionError),
}

A flow graph that cannot be compiled into an executable plan.

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.

MissingEntryNode

No entry node was declared.

DuplicateNodeId

Two nodes declared the same logical identifier.

Fields

node: NodeId

Repeated identifier.

UndefinedNode

A transition referenced a node the graph does not declare.

Fields

node: NodeId

Missing identifier.

MissingTransition

A node declared no outgoing transition.

Fields

node: NodeId

Identifier of the node without a transition.

AmbiguousTransition

Two equally specific patterns can match one exit outcome.

Fields

node: NodeId

Identifier of the node with the ambiguity.

first: ExitPattern

First conflicting pattern.

second: ExitPattern

Second conflicting pattern.

UnreachableNode

A node cannot be reached from the entry node.

Fields

node: NodeId

Unreachable identifier.

CyclicGraph

The graph contains a cycle.

Fields

node: NodeId

Identifier revisited on one path.

TooManyNodes

The graph declared more nodes than M3 accepts.

Fields

max: usize

Maximum accepted node count.

TooManyTransitions

The graph declared more transitions than M3 accepts.

Fields

max: usize

Maximum accepted transition count.

TooManyOutgoingTransitions

One node declared more outgoing transitions than M3 accepts.

Fields

node: NodeId

Identifier of the node with too many transitions.

max: usize

Maximum accepted outgoing transition count.

InvalidPattern

An exit pattern violated its bounded format.

Fields

max_bytes: usize

Maximum accepted pattern length in UTF-8 bytes.

ZeroDecisionInputVersion

A decision input-contract version of zero is not a version.

InvalidSplitBranchCount

A split declared fewer than two or more than eight branches.

Fields

split: NodeId

Split whose branch count was invalid.

min: usize

Minimum accepted branch count.

max: usize

Maximum accepted branch count.

InvalidBranchLength

A split branch was empty or longer than the accepted bound.

Fields

split: NodeId

Owning split.

max: usize

Maximum accepted branch length.

SplitIsEntry

A split was declared as the graph entry.

Fields

split: NodeId

Rejected split.

InvalidSplitJoin

A split did not reference a declared structural join.

Fields

split: NodeId

Owning split.

join: NodeId

Missing or wrongly typed join.

JoinHasMultipleOwners

More than one split tried to own the same join.

Fields

join: NodeId

Multiply owned join.

first: NodeId

First owning split.

second: NodeId

Second owning split.

OrphanJoin

A join was not owned by any split.

Fields

join: NodeId

Unowned join.

JoinHasExternalEntry

A normal transition attempted to enter a structural join.

Fields

join: NodeId

Join with an external incoming edge.

SplitHasExplicitTransition

A split tried to bypass its implicit join edge.

Fields

split: NodeId

Split with the explicit edge.

ParallelBudgetExceedsBranches

The branch concurrency budget exceeded the declared branch count.

Fields

split: NodeId

Split with the contradictory budget.

branches: usize

Declared branch count.

InvalidParallelBranchBudget

A branch concurrency budget was zero or above the M4 ceiling.

Fields

max: usize

Maximum accepted branch concurrency.

InvalidPartitionWorkerBudget

A partition-worker budget was zero or above the M4 ceiling.

Fields

max: u8

Maximum accepted worker concurrency.

InsufficientPoolCapacity

The declared pool cannot supply active children plus their parent.

Fields

required: u32

Minimum required connection count.

configured: u32

Declared connection count.

InvalidPartitionCount

A durable partition count was zero or above the M4 ceiling.

Fields

max: u16

Maximum accepted partition count.

Token(DefinitionError)

A logical identifier or revision token was invalid.

Manifest(DefinitionError)

The canonical manifest could not be encoded within its bound.

Trait Implementations

impl Clone for PlanError

fn clone(&self) -> PlanError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanError

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

Formats the value using the given formatter.

impl Display for PlanError

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

Formats the value using the given formatter.

impl Eq for PlanError

impl Error for PlanError

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 From<DefinitionError> for PlanError

fn from(error: DefinitionError) -> Self

Converts to this type from the input type.

impl PartialEq for PlanError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PlanError