Struct ChobitMap 

pub struct ChobitMap<T> { /* private fields */ }

This is a so-called HashMap, but key is specialized by u64.

ChobitMap is the faster than Rust’s HashMap.

Implementations

impl<T> ChobitMap<T>

pub fn new(table_size: usize) -> Self

Creates ChobitMap.

• table_size : Key-value table size. this is repaired into power of 2.
• Return : Instance.

use chobitlibs::chobit_map::ChobitMap;

let map = ChobitMap::<i32>::new(200);
assert_eq!(map.table_size(), 128);

pub fn table_size(&self) -> usize

Gets key-value table size.

• Return : Key-value table size.

pub fn get(&self, key: u64) -> Option<&T>

Gets a value by key.

• key : A key of the value.
• Return : If key exists, returns the value. Otherwise, returns None.

use chobitlibs::chobit_map::ChobitMap;

let mut map = ChobitMap::<i32>::new(200);

let key_1: u64 = 111;
let value_1: i32 = 100;

let key_2: u64 = 222;
let value_2: i32 = 200;

let key_3: u64 = 333;
let value_3: i32 = 300;

assert!(map.add(key_1, value_1).is_ok());
assert!(map.add(key_2, value_2).is_ok());
assert!(map.add(key_3, value_3).is_ok());

assert_eq!(*map.get(key_1).unwrap(), value_1);
assert_eq!(*map.get(key_2).unwrap(), value_2);
assert_eq!(*map.get(key_3).unwrap(), value_3);

pub fn get_mut(&mut self, key: u64) -> Option<&mut T>

Gets a mutable value by key.

• key : A key of the value.
• Return : If key exists, returns the mutable value. Otherwise, returns None.

use chobitlibs::chobit_map::ChobitMap;

let mut map = ChobitMap::<i32>::new(200);

let key_1: u64 = 111;
let value_1: i32 = 100;

let key_2: u64 = 222;
let value_2: i32 = 200;

let key_3: u64 = 333;
let value_3: i32 = 300;

assert!(map.add(key_1, value_1).is_ok());
assert!(map.add(key_2, value_2).is_ok());
assert!(map.add(key_3, value_3).is_ok());

assert_eq!(*map.get(key_1).unwrap(), value_1);
assert_eq!(*map.get(key_2).unwrap(), value_2);
assert_eq!(*map.get(key_3).unwrap(), value_3);

let value_1_2: i32 = 1000;
let value_2_2: i32 = 2000;
let value_3_2: i32 = 3000;

*map.get_mut(key_1).unwrap() = value_1_2;
*map.get_mut(key_2).unwrap() = value_2_2;
*map.get_mut(key_3).unwrap() = value_3_2;

assert_eq!(*map.get(key_1).unwrap(), value_1_2);
assert_eq!(*map.get(key_2).unwrap(), value_2_2);
assert_eq!(*map.get(key_3).unwrap(), value_3_2);

pub fn add(&mut self, key: u64, value: T) -> Result<(), ChobitMapError>

Adds a value.

• key : A key of the value.
• value : A value that you want to put into ChobitMap.
• Return : If the key is conflicted, returns error. Otherwise, returns the value.

use chobitlibs::chobit_map::ChobitMap;

let mut map = ChobitMap::<i32>::new(200);

let key_1: u64 = 111;
let value_1: i32 = 100;

let key_2: u64 = 222;
let value_2: i32 = 200;

let key_3: u64 = 333;
let value_3: i32 = 300;

assert!(map.add(key_1, value_1).is_ok());
assert!(map.add(key_2, value_2).is_ok());
assert!(map.add(key_3, value_3).is_ok());

assert_eq!(*map.get(key_1).unwrap(), value_1);
assert_eq!(*map.get(key_2).unwrap(), value_2);
assert_eq!(*map.get(key_3).unwrap(), value_3);

pub fn remove(&mut self, key: u64) -> Result<T, ChobitMapError>

Removes a value.

• key : A key of the value.
• Return : If key exists, returns the value. Otherwise, returns error.

use chobitlibs::chobit_map::ChobitMap;

let mut map = ChobitMap::<i32>::new(200);

let key_1: u64 = 111;
let value_1: i32 = 100;

let key_2: u64 = 222;
let value_2: i32 = 200;

let key_3: u64 = 333;
let value_3: i32 = 300;

assert!(map.add(key_1, value_1).is_ok());
assert!(map.add(key_2, value_2).is_ok());
assert!(map.add(key_3, value_3).is_ok());

assert_eq!(*map.get(key_1).unwrap(), value_1);
assert_eq!(*map.get(key_2).unwrap(), value_2);
assert_eq!(*map.get(key_3).unwrap(), value_3);

assert_eq!(map.remove(key_1).unwrap(), value_1);
assert_eq!(map.remove(key_2).unwrap(), value_2);
assert_eq!(map.remove(key_3).unwrap(), value_3);

assert!(map.get(key_1).is_none());
assert!(map.get(key_2).is_none());
assert!(map.get(key_3).is_none());

pub fn iter(&self) -> Iter<'_, T>

Makes a iterator.

• Return : A iterator of ChobitMap.

use chobitlibs::chobit_map::ChobitMap;

let mut map = ChobitMap::<i32>::new(200);

let key_1: u64 = 1;
let value_1: i32 = 100;

let key_2: u64 = 2;
let value_2: i32 = 200;

let key_3: u64 = 3;
let value_3: i32 = 300;

assert!(map.add(key_1, value_1).is_ok());
assert!(map.add(key_2, value_2).is_ok());
assert!(map.add(key_3, value_3).is_ok());

let mut iter = map.iter();

assert_eq!(iter.next().unwrap(), (key_1, &value_1));
assert_eq!(iter.next().unwrap(), (key_2, &value_2));
assert_eq!(iter.next().unwrap(), (key_3, &value_3));
assert!(iter.next().is_none());