Enum orx_linked_list::NodeIndexError

pub enum NodeIndexError {
    RemovedNode,
    WrongCollection,
    ReorganizedCollection,
}

Error observed while using a NodeIndex to access a node in a SelfRefCol.

Variants

RemovedNode

RemovedNode => Referenced node is removed from the collection. Node index can only be used if the corresponding node still belongs to the collection.

Examples

use orx_selfref_col::*;

#[derive(Clone, Copy, Debug)]
struct Var;
impl<'a> Variant<'a, char> for Var {
    type Storage = NodeDataLazyClose<char>;
    type Prev = NodeRefSingle<'a, Self, char>;
    type Next = NodeRefsVec<'a, Self, char>;
    type Ends = NodeRefsArray<'a, 2, Self, char>;
    type MemoryReclaim = MemoryReclaimOnThreshold<2>;
}

let mut col = SelfRefCol::<Var, _>::new();
let [a, b, c, d, e, f, g] = col
    .mutate_take(['a', 'b', 'c', 'd', 'e', 'f', 'g'], |x, values| {
        values.map(|val| x.push_get_ref(val).index(&x))
    });

let removed_b = col.mutate_take(b, |x, b| x.as_node_ref(b).close_node_take_data(&x)); // does not trigger reclaim yet
assert_eq!(removed_b, 'b');

assert_eq!(a.invalidity_reason_for_collection(&col), None);
assert_eq!(c.invalidity_reason_for_collection(&col), None);

assert_eq!(b.invalidity_reason_for_collection(&col), Some(NodeIndexError::RemovedNode));

WrongCollection

WrongCollection => Node index is used on a collection different than the collection it is created for. Node indices can only be used for the collection they belong to.

Examples

use orx_selfref_col::*;

#[derive(Clone, Copy, Debug)]
struct Var;
impl<'a> Variant<'a, char> for Var {
    type Storage = NodeDataLazyClose<char>;
    type Prev = NodeRefSingle<'a, Self, char>;
    type Next = NodeRefsVec<'a, Self, char>;
    type Ends = NodeRefsArray<'a, 2, Self, char>;
    type MemoryReclaim = MemoryReclaimOnThreshold<2>;
}

let mut col1 = SelfRefCol::<Var, _>::new();
let a = col1.mutate_take('a', |x, a| x.push_get_ref(a).index(&x));

let col2 = SelfRefCol::<Var, _>::new();

assert_eq!(a.invalidity_reason_for_collection(&col1), None);
assert_eq!(a.invalidity_reason_for_collection(&col2), Some(NodeIndexError::WrongCollection));

ReorganizedCollection

ReorganizedCollection => All nodes of the containing collection is re-organized in order to reclaim memory of closed nodes. Such a reorganization happens only if the collection uses MemoryReclaimOnThreshold policy and utilization level of memory drops below the threshold due to pop and remove operations. It is never observed if the list only grows or if MemoryReclaimNever policy is used. In this case, the references need to be recreated.

Examples

use orx_selfref_col::*;

#[derive(Clone, Copy, Debug)]
struct Var;
impl<'a> Variant<'a, char> for Var {
    type Storage = NodeDataLazyClose<char>;
    type Prev = NodeRefSingle<'a, Self, char>;
    type Next = NodeRefsVec<'a, Self, char>;
    type Ends = NodeRefsArray<'a, 2, Self, char>;
    type MemoryReclaim = MemoryReclaimOnThreshold<2>;
}

let mut col = SelfRefCol::<Var, _>::new();
let [a, b, c] = col.mutate_take(['a', 'b', 'c'], |x, values| {
    values.map(|val| x.push_get_ref(val).index(&x))
});

// triggers memory reclaim, invalidating all prior node indices
let removed_b = col.mutate_take(b, |x, b| x.as_node_ref(b).close_node_take_data(&x));
assert_eq!(removed_b, 'b');

assert_eq!(a.invalidity_reason_for_collection(&col), Some(NodeIndexError::ReorganizedCollection));
assert_eq!(b.invalidity_reason_for_collection(&col), Some(NodeIndexError::ReorganizedCollection));
assert_eq!(c.invalidity_reason_for_collection(&col), Some(NodeIndexError::ReorganizedCollection));

Trait Implementations

impl Clone for NodeIndexError

fn clone(&self) -> NodeIndexError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeIndexError

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

Formats the value using the given formatter.

impl Display for NodeIndexError

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

Formats the value using the given formatter.

impl Error for NodeIndexError

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 NodeIndexError

fn eq(&self, other: &NodeIndexError) -> 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 Copy for NodeIndexError

impl Eq for NodeIndexError

impl StructuralPartialEq for NodeIndexError