Struct map 

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

cpp class: template<class K, class V, class Compare, class Allocator> std::map<K, V, Compare, Allocator>

Implementations

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

pub fn is_empty(&self) -> bool

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

pub fn size(&self) -> usize

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

pub fn max_size(&self) -> usize

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

pub fn clear(&mut self)

use hicc_std::MapIntInt;
let mut map = MapIntInt::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 <map<K, V> as AbiType>::InputType)

use hicc_std::MapIntInt;
let mut map1 = MapIntInt::new();
map1.insert(&1, &2);
let mut map2 = MapIntInt::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::MapIntInt;
let mut map = MapIntInt::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::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
assert!(map.contains(&1));
assert!(!map.contains(&2));

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

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

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.assign(&mut MapIntInt::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::MapIntInt;
let mut map = MapIntInt::new();
assert!(map.insert(&1, &2));
assert_eq!(map.get(&1), Some(&2));
assert!(!map.insert(&1, &2));

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

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

impl<K: AbiType, V: AbiType> map<K, V>

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

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

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

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

use hicc_std::{string, MapIntString};
use hicc::AbiClass;
let mut map = MapIntString::new();
map.insert(&1, &string::from(c"hello"));
assert!(*map.get(&1).unwrap() == 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::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
let mut it = map.iter();
assert_eq!(it.next(), Some((&1, &2)));
assert_eq!(it.next(), Some((&2, &3)));
assert!(it.next().is_none());

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

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
map.iter_mut().for_each(|(_, v)| *v += 1);
let mut it = map.iter();
assert_eq!(it.next(), Some((&1, &3)));
assert_eq!(it.next(), Some((&2, &4)));
assert!(it.next().is_none());

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

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
let mut it = map.rev_iter();
assert_eq!(it.next(), Some((&2, &3)));
assert_eq!(it.next(), Some((&1, &2)));
assert!(it.next().is_none());

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

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
map.rev_iter_mut().for_each(|(_, v)| *v += 1);
let mut it = map.rev_iter();
assert_eq!(it.next(), Some((&2, &4)));
assert_eq!(it.next(), Some((&1, &3)));
assert!(it.next().is_none());

pub fn iter_lower_upper_bound( &self, lower_key: Option<&K::InputType>, upper_key: Option<&K::InputType>, ) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRef<'_>)>

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
map.insert(&3, &4);
let mut it = map.iter_lower_upper_bound(Some(&1), Some(&2));
assert_eq!(it.next(), Some((&1, &2)));
assert_eq!(it.next(), Some((&2, &3)));
assert_eq!(it.next(), None);

pub fn iter_lower_upper_bound_mut( &mut self, lower_key: Option<&K::InputType>, upper_key: Option<&K::InputType>, ) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRefMut<'_>)>

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &2);
map.insert(&2, &3);
map.insert(&3, &4);
map.iter_lower_upper_bound_mut(Some(&1), Some(&2)).for_each(|(_, v)| *v -= 1);
let mut it = map.iter_lower_upper_bound(Some(&1), Some(&2));
assert_eq!(it.next(), Some((&1, &1)));
assert_eq!(it.next(), Some((&2, &2)));
assert_eq!(it.next(), None);

pub fn rev_iter_lower_upper_bound( &self, lower_key: Option<&K::InputType>, upper_key: Option<&K::InputType>, ) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRef<'_>)>

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &0);
map.insert(&2, &1);
map.insert(&3, &2);
let mut it = map.rev_iter_lower_upper_bound(Some(&1), Some(&2));
assert_eq!(it.next(), Some((&2, &1)));
assert_eq!(it.next(), Some((&1, &0)));
assert_eq!(it.next(), None);

pub fn rev_iter_lower_upper_bound_mut( &mut self, lower_key: Option<&K::InputType>, upper_key: Option<&K::InputType>, ) -> impl Iterator<Item = (K::OutputRef<'_>, V::OutputRefMut<'_>)>

use hicc_std::MapIntInt;
let mut map = MapIntInt::new();
map.insert(&1, &0);
map.insert(&2, &1);
map.insert(&3, &2);
map.rev_iter_lower_upper_bound_mut(Some(&1), Some(&2)).for_each(|(_, v)| *v -= 1);
let mut it = map.rev_iter_lower_upper_bound(Some(&1), Some(&2));
assert_eq!(it.next(), Some((&2, &0)));
assert_eq!(it.next(), Some((&1, &-1)));
assert_eq!(it.next(), None);

Trait Implementations

impl<K: AbiType + 'static, V: AbiType + 'static> AbiClass for 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 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 map<K, V>

fn drop(&mut self)

Executes the destructor for this type.

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

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