Enum leveled_hash_map::LeveledHashMapError

pub enum LeveledHashMapError<K> {
    KeyTooMany,
    KeyNotExist {
        level: usize,
        key: Arc<K>,
    },
    KeyChainEmpty,
    KeyChainIncorrect {
        level: usize,
        key: Arc<K>,
        last_key: Option<Arc<K>>,
    },
}

Possible errors come from LeveledHashMap.

Variants

KeyTooMany

The length of a key chain is over the max level of a LeveledHashMap.

extern crate leveled_hash_map;

use std::sync::Arc;

use leveled_hash_map::{LeveledHashMap, LeveledHashMapError};

let mut map = LeveledHashMap::new();

map.insert(&[Arc::new("food")], 100).unwrap();

// now the map has "Level 0", "Level 0" is available to be got, "Level 0" and "Level 1" are available to be inserted

assert_eq!(&100, map.get_advanced(&[Arc::new("food")], 0).unwrap());

// try to get value at "Level 1"

match map.get_professional(&[Arc::new("food"), Arc::new("dessert")], 0) {
    Ok(_) => unreachable!(),
    Err(err) => match err {
        LeveledHashMapError::KeyTooMany => (),
        _ => unreachable!()
    }
}

// try to insert value to "Level 2"

match map.insert(&[Arc::new("food"), Arc::new("dessert"), Arc::new("cake")], 10) {
    Ok(_) => unreachable!(),
    Err(err) => match err {
        LeveledHashMapError::KeyTooMany => (),
        _ => unreachable!()
    }
}

// try to insert value to "Level 1"

match map.insert(&[Arc::new("food"), Arc::new("dessert")], 10) {
    Ok(_) => (),
    Err(err) => unreachable!()
}

KeyNotExist

The key chain is correct, but the last key in the key chain does not exist.

extern crate leveled_hash_map;

use std::sync::Arc;

use leveled_hash_map::{LeveledHashMap, LeveledHashMapError};

let mut map = LeveledHashMap::new();

map.insert(&[Arc::new("food")], 100).unwrap();

map.insert(&[Arc::new("food"), Arc::new("dessert")], 100).unwrap();

map.insert(&[Arc::new("food"), Arc::new("dessert"), Arc::new("cake")], 100).unwrap();

// try to get "food/dessert/chocolate"

match map.get_professional(&[Arc::new("food"), Arc::new("dessert"), Arc::new("chocolate")], 0) {
    Ok(_) => unreachable!(),
    Err(err) => {
        match err {
            LeveledHashMapError::KeyNotExist {
                level,
                key,
            } => {
                assert_eq!(2, level);
                assert_eq!(Arc::new("chocolate"), key);
            }
            _ => unreachable!(),
        }
    }
}

Fields of KeyNotExist

level: usizekey: Arc<K>

KeyChainEmpty

The key chain is empty.

extern crate leveled_hash_map;

use std::sync::Arc;

use leveled_hash_map::{LeveledHashMap, LeveledHashMapError};

let mut map = LeveledHashMap::new();

map.insert(&[Arc::new("food")], 100).unwrap();

// try to get ""

match map.get_professional(&[], 0) {
    Ok(_) => unreachable!(),
    Err(err) => {
        match err {
            LeveledHashMapError::KeyChainEmpty => (),
            _ => unreachable!(),
        }
    }
}

KeyChainIncorrect

The key chain is incorrect.

extern crate leveled_hash_map;

use std::sync::Arc;

use leveled_hash_map::{LeveledHashMap, LeveledHashMapError};

let mut map = LeveledHashMap::new();

map.insert(&[Arc::new("food")], 100).unwrap();

map.insert(&[Arc::new("food"), Arc::new("meat")], 200).unwrap();

map.insert(&[Arc::new("food"), Arc::new("dessert")], 100).unwrap();

map.insert(&[Arc::new("food"), Arc::new("dessert"), Arc::new("cake")], 100).unwrap();

// try to get "food/meat/chocolate", here "food/meat" exists

match map.get_professional(&[Arc::new("food"), Arc::new("meat"), Arc::new("cake")], 0) {
    Ok(_) => unreachable!(),
    Err(err) => {
        match err {
            LeveledHashMapError::KeyChainIncorrect {
                level,
                key,
                last_key,
            } => {
                assert_eq!(2, level);
                assert_eq!(Arc::new("cake"), key);
                assert_eq!(Some(Arc::new("dessert")), last_key);
            }
            _ => unreachable!(),
        }
    }
}

Fields of KeyChainIncorrect

level: usizekey: Arc<K>last_key: Option<Arc<K>>

Trait Implementations

impl<K> Debug for LeveledHashMapError<K>

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

Formats the value using the given formatter.

impl<K> Display for LeveledHashMapError<K>

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

Formats the value using the given formatter.

impl<K> Error for LeveledHashMapError<K>

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() { // Print e itself, no need for description(). eprintln!("Error: {}", e); }

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting