Struct vector 

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

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

Implementations

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

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
assert_eq!(vec.get(0), None);
vec.push_back(&1);
assert_eq!(vec.get(0), Some(&1));

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

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

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
assert_eq!(vec.back(), None);
vec.push_back(&1);
assert_eq!(vec.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::VecInt;
let mut vec = VecInt::new();
assert_eq!(vec.back_mut(), None);
vec.push_back(&1);
*vec.back_mut().unwrap() += 1;
assert_eq!(vec.back(), Some(&2));

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

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
assert_eq!(vec.front(), None);
vec.push_back(&1);
assert_eq!(vec.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::VecInt;
let mut vec = VecInt::new();
assert_eq!(vec.front_mut(), None);
vec.push_back(&1);
*vec.front_mut().unwrap() += 1;
assert_eq!(vec.front(), Some(&2));

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

pub fn pop_back(&mut self)

如果为空不做任何改变.

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

pub fn is_empty(&self) -> bool

use hicc_std::VecInt;
let vec = VecInt::new();
assert!(vec.is_empty());

pub fn size(&self) -> usize

use hicc_std::VecInt;
let vec = VecInt::new();
assert_eq!(vec.size(), 0);

pub fn max_size(&self) -> usize

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

pub fn capacity(&self) -> usize

use hicc_std::VecInt;
let vec = VecInt::new();
println!("vec.capacity = {}", vec.capacity());

pub fn clear(&mut self)

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

pub fn reserve(&mut self, n: usize)

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.reserve(10_usize);
assert!(vec.is_empty());
println!("vec.capacity = {}", vec.capacity());

pub fn shrink_to_fit(&mut self)

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.reserve(10_usize);
vec.shrink_to_fit();
println!("vec.capacity = {}", vec.capacity());

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.resize(10, &1);
assert_eq!(vec.size(), 10);
assert_eq!(vec.back(), Some(&1));
vec.as_slice().iter().for_each(|v| println!("{v}"));

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

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

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.push_back(&1);
assert_eq!(vec.front(), Some(&1));

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

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.push_back(&1);
vec.swap(&mut VecInt::new());
assert!(vec.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&) 如果pos超出范围则追加到最后.

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.insert(0, 2, &1);
vec.insert(vec.size(), 1, &2);
assert_eq!(vec.as_slice(), &[1, 1, 2]);

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

cpp global function: void SelfMethods::erase(Self&, size_t, size_t) 如果pos超出范围则不做任何改变.

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.insert(0, 10, &2);
vec.erase(1, 9);
assert_eq!(vec.size(), 1);

impl<T: Sized + 'static> vector<Pod<T>>

pub fn as_slice(&self) -> &[T]

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.insert(0, 2, &2);
assert_eq!(vec.as_slice(), &[2, 2]);

pub fn as_slice_mut(&mut self) -> &mut [T]

use hicc_std::VecInt;
let mut vec = VecInt::new();
vec.insert(0, 2, &2);
vec.as_slice_mut().iter_mut().for_each(|v| {*v += 1;});
assert_eq!(vec.as_slice(), &[3, 3]);

impl<T: AbiClass + 'static> vector<T>

pub fn as_array(&self) -> ClassArray<'_, T>

use hicc_std::{VecString, string};
let mut vec = VecString::new();
let msg = string::with_cstr(c"hello");
vec.insert(0, 10, &msg);
vec.as_array().iter().for_each(|msg| { println!("msg.size() = {}", msg.size()); });

impl<T: AbiClass + 'static> vector<T>

pub fn as_mut_array(&mut self) -> ClassMutArray<'_, T>

use hicc_std::{VecString, string};
let mut vec = VecString::new();
let msg = string::with_cstr(c"hello");
vec.insert(0, 10, &msg);
vec.as_mut_array().iter_mut().for_each(|mut msg| { msg.append(1, b'c' as i8); });

Trait Implementations

impl<T: AbiType + 'static> AbiClass for vector<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 vector<T>

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

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