Enum LeveledHashMapError

Source

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

Expand description

Possible errors come from LeveledHashMap.

Variants§

§

KeyTooMany

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

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.

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

§level: usize

§key: Arc<K>

§

KeyChainEmpty

The key chain is empty.

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.

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!(),
        }
    }
}