Struct deque 

pub struct deque<T: AbiType + 'static> { /* private fields */ }

cpp class: template<class T, class Allocator> std::deque<T, Allocator>

Implementations

impl<T: AbiType + 'static> deque<T>

pub fn get(&self, pos: usize) -> Option<T::OutputRef<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.get(0), None);
deque.push_front(&1);
assert_eq!(deque.get(0), Some(&1));

pub fn get_mut(&mut self, pos: usize) -> Option<T::OutputRefMut<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.get(0), None);
deque.push_front(&1);
*deque.get_mut(0).unwrap() += 1;
assert_eq!(deque.get(0), Some(&2));

pub fn back(&self) -> Option<T::OutputRef<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.back(), None);
deque.push_back(&1);
assert_eq!(deque.back(), Some(&1));

pub fn back_mut(&mut self) -> Option<T::OutputRefMut<'_>>

1. 如果是hicc::Pod<T>，可通过*back_mut() = <new value>改为.
2. 如果是c++ class, 则必须通过hicc::AbiClass::write改写.

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.back_mut(), None);
deque.push_back(&1);
*deque.back_mut().unwrap() += 1;
assert_eq!(deque.back(), Some(&2));

use hicc_std::{string, DequeString};
use hicc::AbiClass;
let mut deque = DequeString::new();
deque.push_back(&string::from(c"hello"));
assert_eq!(deque.back(), Some(string::from(c"hello").into_ref()));
deque.back_mut().unwrap().write(string::from(c"world"));
assert_eq!(deque.back(), Some(string::from(c"world").into_ref()));

pub fn front(&self) -> Option<T::OutputRef<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.front(), None);
deque.push_back(&1);
assert_eq!(deque.front(), Some(&1));

pub fn front_mut(&mut self) -> Option<T::OutputRefMut<'_>>

1. 如果是hicc::Pod<T>，可通过*back_mut() = <new value>改为.
2. 如果是c++ class, 则必须通过hicc::AbiClass::write改写.

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.front_mut(), None);
deque.push_back(&1);
*deque.front_mut().unwrap() += 1;
assert_eq!(deque.front_mut(), Some(&mut 2));

use hicc_std::{string, DequeString};
use hicc::AbiClass;
let mut deque = DequeString::new();
deque.push_back(&string::from(c"hello"));
assert_eq!(deque.front(), Some(string::from(c"hello").into_ref()));
deque.front_mut().unwrap().write(string::from(c"world"));
assert_eq!(deque.front(), Some(string::from(c"world").into_ref()));

pub fn pop_back(&mut self)

如果为空不做任何改变.

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.pop_back();
deque.push_back(&1);
deque.pop_back();
assert!(deque.is_empty());

pub fn pop_front(&mut self)

如果为空不做任何改变.

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.pop_front();
deque.push_front(&1);
deque.pop_front();
assert!(deque.is_empty());

pub fn is_empty(&self) -> bool

use hicc_std::DequeInt;
let deque = DequeInt::new();
assert!(deque.is_empty());

pub fn size(&self) -> usize

use hicc_std::DequeInt;
let deque = DequeInt::new();
assert_eq!(deque.size(), 0);

pub fn max_size(&self) -> usize

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

pub fn clear(&mut self)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_back(&1);
deque.clear();
assert!(deque.is_empty());

pub fn shrink_to_fit(&mut self)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.resize(10, &1);
deque.push_front(&2);
// ...
deque.shrink_to_fit();

pub fn resize(&mut self, n: usize, val: &<T as AbiType>::InputType)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.resize(10, &1);
assert_eq!(deque.size(), 10);
assert_eq!(deque.back(), Some(&1));
assert_eq!(deque.front(), Some(&1));
assert_eq!(deque.get(5), Some(&1));

pub fn assign(&mut self, n: usize, val: &<T as AbiType>::InputType)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.assign(10, &1);
assert_eq!(deque.size(), 10);

pub fn push_back(&mut self, val: &<T as AbiType>::InputType)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
assert_eq!(deque.front(), None);
deque.push_back(&1);
assert_eq!(deque.front(), Some(&1));

pub fn push_front(&mut self, val: &<T as AbiType>::InputType)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_front(&1);
assert_eq!(deque.front(), Some(&1));

pub fn swap(&mut self, other: &mut <deque<T> as AbiType>::InputType)

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_back(&1);
deque.swap(&mut DequeInt::new());
assert!(deque.is_empty());

pub fn insert( &mut self, pos: usize, count: usize, val: &<T as AbiType>::InputType, )

cpp global function: void SelfMethods::insert(Self&, size_t, size_t, const T&)

pub fn erase(&mut self, pos: usize, count: usize)

cpp global function: void SelfMethods::erase(Self&, size_t, size_t)

impl<T: AbiType> deque<T>

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

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_front(&1);
deque.push_front(&2);
let mut it = deque.iter();
assert_eq!(it.next(), Some(&2));
assert_eq!(it.next(), Some(&1));
assert_eq!(it.next(), None);

pub fn iter_mut(&mut self) -> impl Iterator<Item = T::OutputRefMut<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_front(&1);
deque.push_front(&3);
deque.iter_mut().for_each(|v| *v += 1);
let mut it = deque.iter();
assert_eq!(it.next(), Some(&4));
assert_eq!(it.next(), Some(&2));
assert_eq!(it.next(), None);

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

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_front(&1);
deque.push_front(&2);
let mut it = deque.rev_iter();
assert_eq!(it.next(), Some(&1));
assert_eq!(it.next(), Some(&2));
assert_eq!(it.next(), None);

pub fn rev_iter_mut(&mut self) -> impl Iterator<Item = T::OutputRefMut<'_>>

use hicc_std::DequeInt;
let mut deque = DequeInt::new();
deque.push_front(&1);
deque.push_front(&3);
deque.rev_iter_mut().for_each(|v| *v += 1);
let mut it = deque.rev_iter();
assert_eq!(it.next(), Some(&2));
assert_eq!(it.next(), Some(&4));
assert_eq!(it.next(), None);

Trait Implementations

impl<T: AbiType + 'static> AbiClass for deque<T>

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<T: AbiType + 'static> Debug for deque<T>

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

Formats the value using the given formatter.

impl<T: AbiType + 'static> Drop for deque<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: AbiType + Sync> Send for deque<T>

impl<T: AbiType + Sync> Sync for deque<T>