Struct IndexMap 

pub struct IndexMap<K, V, S = RandomState> {
    pub values: Vec<V>,
    pub keys: Vec<K>,
    pub hashes: Vec<u64>,
    pub table: HashTable<usize>,
    pub hash_builder: S,
}

IndexMap 連続領域を保証するHashMap

Safety

table, hashes は table_* メソッドが責任をもつこと 更新とか

いじんないじんないじんな いじったならあらゆるUnitTest書いて通せ

Fields

values: Vec<V>

keys: Vec<K>

hashes: Vec<u64>

table: HashTable<usize>

hash_builder: S

Implementations

impl<K, V, S> IndexMap<K, V, S>

where K: Eq + Hash + Clone, S: BuildHasher,

pub fn with_hasher(hash_builder: S) -> Self

pub fn with_capacity(capacity: usize) -> Self

where S: Default,

pub fn new() -> Self

where S: Default,

pub fn len(&self) -> usize

pub fn iter_values(&self) -> Iter<'_, V>

pub fn iter_keys(&self) -> Iter<'_, K>

pub fn iter(&self) -> IndexMapIter<'_, K, V, S>

pub fn values(&self) -> &Vec<V>

pub fn keys(&self) -> &Vec<K>

pub fn get(&self, key: &K) -> Option<&V>

pub fn get_mut(&mut self, key: &K) -> Option<&mut V>

pub fn get_with_index(&self, index: usize) -> Option<&V>

pub fn get_with_index_mut(&mut self, index: usize) -> Option<&mut V>

pub fn get_key_with_index(&self, index: usize) -> Option<&K>

pub fn get_key_value_with_index(&self, index: usize) -> Option<(&K, &V)>

pub fn get_index(&self, key: &K) -> Option<usize>

pub fn contains_key(&self, key: &K) -> bool

pub fn insert(&mut self, key: &K, value: V) -> Option<InsertResult<K, V>>

pub fn entry_mut<'a>(&'a mut self, key: &'a K) -> EntryMut<'a, K, V, S>

pub fn swap_remove(&mut self, key: &K) -> Option<V>

pub fn from_kv_vec(k_vec: Vec<K>, v_vec: Vec<V>) -> Self

where S: BuildHasher + Default,

Trait Implementations

impl<K: Clone, V: Clone, S: Clone> Clone for IndexMap<K, V, S>

fn clone(&self) -> IndexMap<K, V, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S: Debug> Debug for IndexMap<K, V, S>

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

Formats the value using the given formatter.

impl<'de, K, V> Deserialize<'de> for IndexMap<K, V>

where K: Deserialize<'de> + Hash + Eq + Clone, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> Serialize for IndexMap<K, V>

where K: Serialize, V: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.