Enum GraphError 

pub enum GraphError {
    NodeNotFound {
        node: String,
        graph_size: usize,
        context: String,
    },
    EdgeNotFound {
        src_node: String,
        target: String,
        context: String,
    },
    InvalidParameter {
        param: String,
        value: String,
        expected: String,
        context: String,
    },
    AlgorithmFailure {
        algorithm: String,
        reason: String,
        iterations: usize,
        tolerance: f64,
    },
    IOError {
        path: String,
        source: Error,
    },
    MemoryError {
        requested: usize,
        available: usize,
        context: String,
    },
    ConvergenceError {
        algorithm: String,
        iterations: usize,
        tolerance: f64,
        threshold: f64,
    },
    GraphStructureError {
        expected: String,
        found: String,
        context: String,
    },
    NoPath {
        src_node: String,
        target: String,
        nodes: usize,
        edges: usize,
    },
    CycleDetected {
        start_node: String,
        cycle_length: usize,
    },
    LinAlgError {
        operation: String,
        details: String,
    },
    SparseError {
        details: String,
    },
    CoreError(CoreError),
    SerializationError {
        format: String,
        details: String,
    },
    InvalidAttribute {
        attribute: String,
        target_type: String,
        details: String,
    },
    Cancelled {
        operation: String,
        elapsed_time: f64,
    },
    ConcurrencyError {
        operation: String,
        details: String,
    },
    FormatError {
        format: String,
        version: String,
        supported: String,
    },
    InvalidGraph(String),
    AlgorithmError(String),
    ComputationError(String),
    Other(String),
}

Error type for graph processing operations

Provides detailed error information with context and suggestions for recovery. All errors include location information when possible.

Variants

NodeNotFound

Node not found in the graph

Fields

node: String

The node that was not found

graph_size: usize

Size of the graph for context

context: String

Additional context about the operation

EdgeNotFound

Edge not found in the graph

Fields

src_node: String

Source node of the edge

target: String

Target node of the edge

context: String

Additional context about the operation

InvalidParameter

Invalid parameter provided to an operation

Fields

param: String

Parameter name

value: String

Provided value

expected: String

Expected value or range

context: String

Additional context

AlgorithmFailure

Algorithm failed to converge or complete

Fields

algorithm: String

Name of the algorithm

reason: String

Reason for failure

iterations: usize

Number of iterations completed

tolerance: f64

Tolerance used

IOError

I/O operation failed

Fields

path: String

File path that caused the error

source: Error

Underlying I/O error

MemoryError

Memory allocation or usage error

Fields

requested: usize

Requested memory in bytes

available: usize

Available memory in bytes

context: String

Additional context

ConvergenceError

Algorithm did not converge within specified limits

Fields

algorithm: String

Algorithm name

iterations: usize

Iterations completed

tolerance: f64

Final tolerance achieved

threshold: f64

Required threshold

GraphStructureError

Graph structure is invalid for the operation

Fields

expected: String

Expected graph property

found: String

Actual graph property

context: String

Additional context

NoPath

No path exists between nodes

Fields

src_node: String

Source node

target: String

Target node

nodes: usize

Number of nodes in graph

edges: usize

Number of edges in graph

CycleDetected

Cycle detected when acyclic graph expected

Fields

start_node: String

Node where cycle starts

cycle_length: usize

Length of the detected cycle

LinAlgError

Linear algebra operation failed

Fields

operation: String

Operation that failed

details: String

Error details

SparseError

Sparse matrix operation failed

Fields

details: String

Error details

CoreError(CoreError)

Core module error

SerializationError

Serialization/deserialization failed

Fields

format: String

Data format (JSON, OxiCode, etc.)

details: String

Error details

InvalidAttribute

Invalid graph attribute

Fields

attribute: String

Attribute name

target_type: String

Target type (node, edge, graph)

details: String

Error details

Cancelled

Computation was cancelled or interrupted

Fields

operation: String

Operation name

elapsed_time: f64

Time elapsed before cancellation

ConcurrencyError

Thread safety or concurrency error

Fields

operation: String

Operation name

details: String

Error details

FormatError

Invalid graph format or version

Fields

format: String

Format name

version: String

Version found

supported: String

Supported versions

InvalidGraph(String)

Invalid graph structure (legacy error for backward compatibility)

AlgorithmError(String)

Algorithm error (legacy error for backward compatibility)

ComputationError(String)

Computation error (legacy error for backward compatibility)

Other(String)

Generic error for backward compatibility

Implementations

impl GraphError

pub fn node_not_found<T>(node: T) -> GraphError

where T: Display,

Create a NodeNotFound error with minimal context

pub fn node_not_found_with_context<T>( node: T, graph_size: usize, context: &str, ) -> GraphError

where T: Display,

Create a NodeNotFound error with full context

pub fn edge_not_found<S, T>(source: S, target: T) -> GraphError

where S: Display, T: Display,

Create an EdgeNotFound error with minimal context

pub fn edge_not_found_with_context<S, T>( source: S, target: T, context: &str, ) -> GraphError

where S: Display, T: Display,

Create an EdgeNotFound error with full context

pub fn invalid_parameter<P, V, E>(param: P, value: V, expected: E) -> GraphError

where P: Display, V: Display, E: Display,

Create an InvalidParameter error

pub fn algorithm_failure<A, R>( algorithm: A, reason: R, iterations: usize, tolerance: f64, ) -> GraphError

where A: Display, R: Display,

Create an AlgorithmFailure error

pub fn memory_error( requested: usize, available: usize, context: &str, ) -> GraphError

Create a MemoryError

pub fn convergence_error<A>( algorithm: A, iterations: usize, tolerance: f64, threshold: f64, ) -> GraphError

where A: Display,

Create a ConvergenceError

pub fn graph_structure_error<E, F>( expected: E, found: F, context: &str, ) -> GraphError

where E: Display, F: Display,

Create a GraphStructureError

pub fn no_path<S, T>( source: S, target: T, nodes: usize, edges: usize, ) -> GraphError

where S: Display, T: Display,

Create a NoPath error

pub fn is_recoverable(&self) -> bool

Check if this error is recoverable

pub fn recovery_suggestions(&self) -> Vec<String>

Get suggestions for error recovery

pub fn category(&self) -> &'static str

Get the error category for metrics and logging

Trait Implementations

impl Debug for GraphError

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

Formats the value using the given formatter.

impl Display for GraphError

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

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

fn from(source: CoreError) -> GraphError

Converts to this type from the input type.

impl From<Error> for GraphError

Convert std::io::Error to GraphError with path context

fn from(err: Error) -> GraphError

Converts to this type from the input type.