Enum CsrError 

pub enum CsrError<NodeIndex, EdgeIndex> {
    OffsetLengthOverflow {
        node_count: NodeIndex,
    },
    OffsetLength {
        expected: usize,
        actual: usize,
    },
    FirstOffset {
        actual: EdgeIndex,
    },
    NonMonotonicOffset {
        index: usize,
        previous: EdgeIndex,
        actual: EdgeIndex,
    },
    FinalOffset {
        final_offset: EdgeIndex,
        target_len: usize,
    },
    TargetOutOfRange {
        index: usize,
        target: NodeIndex,
        node_count: NodeIndex,
    },
    TargetUsizeOverflow {
        index: usize,
        value: NodeIndex,
    },
    NodeUsizeOverflow {
        value: NodeIndex,
    },
    EdgeUsizeOverflow {
        value: EdgeIndex,
    },
}

CSR validation error.

Performance

perf: unspecified; errors are returned only from validation paths.

Variants

OffsetLengthOverflow

node_count + 1 overflowed usize.

Fields

node_count: NodeIndex

Node count that could not be converted to an offset length.

OffsetLength

Offset slice length does not equal node_count + 1.

Fields

expected: usize

Expected offset length.

actual: usize

Actual offset length.

FirstOffset

The first CSR offset was not zero.

Fields

actual: EdgeIndex

Actual first offset.

NonMonotonicOffset

Offsets were not monotonically increasing.

Fields

index: usize

Offset index where monotonicity failed.

previous: EdgeIndex

Previous offset value.

actual: EdgeIndex

Actual offset value at index.

FinalOffset

Final offset does not match target slice length.

Fields

final_offset: EdgeIndex

Final offset value.

target_len: usize

Target slice length.

TargetOutOfRange

Target node ID is outside 0..node_count.

Fields

index: usize

Target slice index containing the bad value.

target: NodeIndex

Bad target node ID.

node_count: NodeIndex

Number of nodes in the graph.

TargetUsizeOverflow

A target node ID value could not be represented as usize on this target (a width failure, distinct from an out-of-range target).

Fields

index: usize

Target slice index containing the value.

value: NodeIndex

Target value that did not fit in usize.

NodeUsizeOverflow

A node index value could not be represented as usize on this target.

Fields

value: NodeIndex

Node value that could not be represented as usize.

EdgeUsizeOverflow

An edge index value could not be represented as usize on this target.

Fields

value: EdgeIndex

Edge value that could not be represented as usize.

Trait Implementations

impl<NodeIndex: Clone, EdgeIndex: Clone> Clone for CsrError<NodeIndex, EdgeIndex>

fn clone(&self) -> CsrError<NodeIndex, EdgeIndex>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NodeIndex: Debug, EdgeIndex: Debug> Debug for CsrError<NodeIndex, EdgeIndex>

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

Formats the value using the given formatter.

impl<NodeIndex, EdgeIndex> Display for CsrError<NodeIndex, EdgeIndex>

where NodeIndex: Display, EdgeIndex: Display,

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

Formats the value using the given formatter.

impl<NodeIndex, EdgeIndex> Error for CsrError<NodeIndex, EdgeIndex>

where NodeIndex: Debug + Display, EdgeIndex: Debug + Display,

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<NodeIndex, EdgeIndex> From<CsrError<NodeIndex, EdgeIndex>> for CsrSnapshotError<NodeIndex, EdgeIndex>

fn from(error: CsrError<NodeIndex, EdgeIndex>) -> Self

Converts to this type from the input type.

impl<NodeIndex: PartialEq, EdgeIndex: PartialEq> PartialEq for CsrError<NodeIndex, EdgeIndex>

fn eq(&self, other: &CsrError<NodeIndex, EdgeIndex>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<NodeIndex: Eq, EdgeIndex: Eq> Eq for CsrError<NodeIndex, EdgeIndex>

impl<NodeIndex, EdgeIndex> StructuralPartialEq for CsrError<NodeIndex, EdgeIndex>