Enum leveled_hash_map::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.

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`

Fields

level: usize

key: Arc<K>

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

`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`

Fields

level: usize

key: Arc<K>

last_key: Option<Arc<K>>

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