Struct stack 

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

cpp class: template<class T, class Container> std::stack<T, Container>

Implementations

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

pub fn pop(&mut self)

如果为空不做任何改变.

use hicc_std::StackInt;
let mut stack = StackInt::new();
stack.pop();
stack.push(&1);
assert_eq!(stack.size(), 1);
stack.pop();
assert_eq!(stack.size(), 0);

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

use hicc_std::StackInt;
let mut stack = StackInt::new();
assert_eq!(stack.top(), None);
stack.push(&1);
assert_eq!(stack.top(), Some(&1));

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

use hicc_std::StackInt;
let mut stack = StackInt::new();
assert_eq!(stack.top_mut(), None);
stack.push(&1);
*stack.top_mut().unwrap() += 1;
assert_eq!(stack.top_mut(), Some(&mut 2));

use hicc_std::{string, StackString};
use hicc::AbiClass;
let mut stack = StackString::new();
stack.push(&string::from(c"hello"));
assert_eq!(stack.top(), Some(string::from(c"hello").into_ref()));
stack.top_mut().unwrap().write(string::from(c"world"));
assert_eq!(stack.top(), Some(string::from(c"world").into_ref()));

pub fn is_empty(&self) -> bool

use hicc_std::StackInt;
let mut stack = StackInt::new();
assert!(stack.is_empty());
stack.push(&1);
assert!(!stack.is_empty());

pub fn size(&self) -> usize

use hicc_std::StackInt;
let mut stack = StackInt::new();
assert_eq!(stack.size(), 0);
stack.push(&1);
assert_eq!(stack.size(), 1);

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

use hicc_std::StackInt;
let mut stack = StackInt::new();
stack.push(&1);
assert_eq!(stack.top(), Some(&1));

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

use hicc_std::StackInt;
let mut stack = StackInt::new();
stack.push(&1);
let mut other = StackInt::new();
other.push(&2);
assert_eq!(stack.top(), Some(&1));
assert_eq!(other.top(), Some(&2));
stack.swap(&mut other);
assert_eq!(stack.top(), Some(&2));
assert_eq!(other.top(), Some(&1));

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

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