Struct unordered_map 

pub struct unordered_map<K: AbiType + 'static, V: AbiType + 'static> { /* private fields */ }

cpp class: template <class K, class V, class Hash, class Pred, class Allocator> std::unordered_map<K, V, Hash, Pred, Allocator>

Implementations

impl<K: AbiType + 'static, V: AbiType + 'static> unordered_map<K, V>

pub fn is_empty(&self) -> bool

use hicc_std::UnorderedMapIntInt;
let map = UnorderedMapIntInt::new();
assert!(map.is_empty());

pub fn size(&self) -> usize

use hicc_std::UnorderedMapIntInt;
let map = UnorderedMapIntInt::new();
assert_eq!(map.size(), 0_usize);

pub fn max_size(&self) -> usize

use hicc_std::UnorderedMapIntInt;
let map = UnorderedMapIntInt::new();
println!("map.max_size() = {}", map.max_size());

pub fn clear(&mut self)

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
assert_eq!(map.size(), 1_usize);
map.clear();
assert_eq!(map.size(), 0_usize);

pub fn swap(&mut self, other: &mut <unordered_map<K, V> as AbiType>::InputType)

use hicc_std::UnorderedMapIntInt;
let mut map1 = UnorderedMapIntInt::new();
map1.insert(&1, &2);
let mut map2 = UnorderedMapIntInt::new();
map2.swap(&mut map1);
assert_eq!(map1.size(), 0_usize);
assert_eq!(map2.size(), 1_usize);

pub fn count(&self, key: &<K as AbiType>::InputType) -> usize

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
assert_eq!(map.count(&1), 1);
assert_eq!(map.count(&2), 0);

pub fn contains(&self, key: &<K as AbiType>::InputType) -> bool

cpp global function: bool SelfMethods::contains(const Self&, const K&)

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
assert!(map.contains(&1));
assert!(!map.contains(&2));

pub fn assign(&mut self, other: &<unordered_map<K, V> as AbiType>::InputType)

cpp global function: void hicc::make_assign<Self, Self>(Self&, const Self&)

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
map.assign(&mut UnorderedMapIntInt::new());
assert!(map.is_empty());

pub fn insert( &mut self, key: &<K as AbiType>::InputType, val: &<V as AbiType>::InputType, ) -> bool

cpp global function: bool SelfMethods::insert(Self&, const K&, const V&)

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
assert!(map.insert(&1, &2));
assert!(!map.insert(&1, &2));
assert_eq!(map.get(&1), Some(&2));

pub fn erase(&mut self, key: &<K as AbiType>::InputType) -> usize

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
assert_eq!(map.erase(&1), 0_usize);
assert!(map.insert(&1, &2));
assert_eq!(map.erase(&1), 1_usize);

impl<K: AbiType + 'static, V: AbiType + 'static> unordered_map<K, V>

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

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
assert!(map.get(&2).is_none());
assert_eq!(map.get(&1), Some(&2));

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

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
*map.get_mut(&1).unwrap() = 0;
assert_eq!(map.get(&1), Some(&0));

use hicc_std::{string, UnorderedMapIntString};
use hicc::AbiClass;
let mut map = UnorderedMapIntString::new();
map.insert(&1, &string::from(c"hello"));
map.get_mut(&1).unwrap().write(string::from(c"world"));
assert!(*map.get(&1).unwrap() == string::from(c"world"));

pub fn iter(&self) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRef<'_>)>

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &1);
map.iter().for_each(|(k, v)| println!("key = {k}, value = {v}"));

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRefMut<'_>)>

use hicc_std::UnorderedMapIntInt;
let mut map = UnorderedMapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &1);
map.iter_mut().for_each(|(_, v)| *v += 1);
assert_eq!(map.get(&1), Some(&3));
assert_eq!(map.get(&2), Some(&2));

Trait Implementations

impl<K: AbiType + 'static, V: AbiType + 'static> AbiClass for unordered_map<K, V>

fn get_raw_obj(&self) -> *const ()

仅内部使用.指针携带附加信息，不能转换为c++类指针.

unsafe fn make_ref(&self, obj: *const ()) -> Self

Safety

unsafe fn into_unique(self) -> Self

Safety

fn write(&mut self, other: Self)

更新对象本身.

fn size_of(&self) -> usize

返回c++对象的大小.

fn is_null(&self) -> bool

rust侧的值类型实际都对应到c++侧的对象指针, 检查是否为空指针.

fn as_ref(&self) -> ClassRef<'_, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn as_mut(&mut self) -> ClassRefMut<'_, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn as_ptr(&self) -> ClassPtr<'_, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn as_mut_ptr(&mut self) -> ClassMutPtr<'_, Self>

AbiType::InputMutPtr<'_, T>参数类型实际是&ClassMutPtr<'_, T>, 当需要传递这类参数时可调用此接口.

fn into_ref(self) -> ClassRef<'static, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn into_mut(self) -> ClassRefMut<'static, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn into_ptr(self) -> ClassPtr<'static, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn into_mut_ptr(self) -> ClassMutPtr<'static, Self>

T, ClassRef<'_, T>, ClassRefMut<'_, T>, ClassPtr<'_, T>, ClassMutPtr<'_, T>作为返回值实质是等价.

fn get_obj(&self) -> *const ()

一般内部使用. 返回值等同于c++侧的指针。

impl<K: AbiType + 'static, V: AbiType + 'static> Debug for unordered_map<K, V>

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

Formats the value using the given formatter.

impl<K: AbiType + 'static, V: AbiType + 'static> Drop for unordered_map<K, V>

fn drop(&mut self)

Executes the destructor for this type.

impl<K: AbiType + Sync, V: AbiType + Sync> Send for unordered_map<K, V>

impl<K: AbiType + Sync, V: AbiType + Sync> Sync for unordered_map<K, V>