Enum GraphError 

pub enum GraphError {
    EmptyEdgeId,
    DuplicateNode(NodeId),
    DuplicateEdge(EdgeId),
    MissingEndpoint {
        edge_id: EdgeId,
        endpoint: &'static str,
        node_id: NodeId,
    },
    InvalidWeight {
        edge_id: EdgeId,
        weight: f64,
    },
    InvalidExternalId(String),
    UnknownNode(NodeId),
    UnknownEdge(EdgeId),
    RelabelCollision {
        target: NodeId,
        first: NodeId,
        second: NodeId,
    },
    ParallelEdge {
        kind: GraphKind,
        pair_source: NodeId,
        pair_target: NodeId,
    },
    KindMismatch,
    ConflictingEdge {
        edge_id: EdgeId,
    },
    EdgeIdentityExhausted {
        stored_id: String,
    },
    InvalidOption(String),
}

Graph construction or lookup failure.

Variants

EmptyEdgeId

An edge identifier is empty.

DuplicateNode(NodeId)

The input contains the same node identity more than once.

DuplicateEdge(EdgeId)

The input contains the same edge identity more than once.

MissingEndpoint

An edge endpoint is absent from the selected node set.

Fields

edge_id: EdgeId

Edge containing the invalid endpoint.

endpoint: &'static str

source or target.

node_id: NodeId

Missing node identity.

InvalidWeight

The graph contains an invalid weight.

Fields

edge_id: EdgeId

Edge containing the invalid weight.

weight: f64

Rejected weight.

InvalidExternalId(String)

An external identity is malformed or exceeds its resource bounds.

UnknownNode(NodeId)

A requested node does not exist.

UnknownEdge(EdgeId)

A requested edge does not exist.

RelabelCollision

A relabel operation would merge distinct nodes.

Fields

target: NodeId

Colliding output identity.

first: NodeId

First source identity.

second: NodeId

Second source identity.

ParallelEdge

A simple graph contains parallel endpoint pairs.

Fields

kind: GraphKind

Declared simple graph kind.

pair_source: NodeId

Canonical pair source.

pair_target: NodeId

Canonical pair target.

KindMismatch

Compose requires exactly equal graph kinds.

ConflictingEdge

Two graphs disagree about one stable edge identity.

Fields

edge_id: EdgeId

Conflicting stable edge identity.

EdgeIdentityExhausted

No further structural reverse generation can be represented.

Fields

stored_id: String

Underlying stored Helix edge identity.

InvalidOption(String)

An algorithm option violates its typed runtime contract.

Trait Implementations

impl Clone for GraphError

fn clone(&self) -> GraphError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphError

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

Formats the value using the given formatter.

impl Display for GraphError

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

Formats the value using the given formatter.

impl Error for GraphError

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<GraphError> for GraphLoadError

fn from(source: GraphError) -> Self

Converts to this type from the input type.

impl PartialEq for GraphError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for GraphError