Struct basic_string 

pub struct basic_string<CharT: AbiType + 'static> { /* private fields */ }

cpp class: template<class CharT, class Traits, class Allocator> std::basic_string<CharT, Traits, Allocator>

Implementations

impl<CharT: AbiType + 'static> basic_string<CharT>

pub const npos: usize = usize::MAX

pub fn substr(&self, pos: usize, len: usize) -> Self

如果pos超出范围，会返回空字符串.

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
let substr = s.substr(1, 2);
assert_eq!(substr.as_cstr(), hicc::cstr!("bc"));

pub fn append_str(&mut self, s: &Self, subpos: usize, sublen: usize)

如果subpos超出范围则不做任何改变.

use hicc_std::string;
let mut s1 = string::from(hicc::cstr!("abc"));
let s2 = string::from(hicc::cstr!("def"));
s1.append_str(&s2, 0, 2);
assert_eq!(s1.as_cstr(), hicc::cstr!("abcde"));

pub fn insert_str(&mut self, pos: usize, s: &Self, subpos: usize, sublen: usize)

如果subpos超出范围不做任何改变, 如果pos超出范围则追加到最后.

use hicc_std::string;
let mut s1 = string::from(hicc::cstr!("abc"));
let mut s2 = string::from(hicc::cstr!("def"));
s1.insert_str(0, &s2, 0, string::npos);
assert_eq!(s1.as_cstr(), hicc::cstr!("defabc"));
s1.insert_str(100, &s2, 0, string::npos);
assert_eq!(s1.as_cstr(), hicc::cstr!("defabcdef"));

pub fn insert(&mut self, pos: usize, n: usize, c: CharT::InputType)

如果pos超出范围则追加到最后.

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.insert(0, 3, b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("dddabc"));
s.insert(110, 3, b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("dddabcddd"));

pub fn replace_str( &mut self, pos: usize, len: usize, s: &Self, subpos: usize, sublen: usize, )

如果pos或者subpos超出范围则不做任何改变.

use hicc_std::string;
let mut s1 = string::from(hicc::cstr!("abc"));
let mut s2 = string::from(hicc::cstr!("de"));
s1.replace_str(0, string::npos, &s2, 0, string::npos);
assert_eq!(s1.as_cstr(), hicc::cstr!("de"));

pub fn replace(&mut self, pos: usize, len: usize, n: usize, c: CharT::InputType)

如果pos超出范围则不做任何改变.

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.replace(0, string::npos, 1, b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("d"));

pub fn assign_str(&mut self, s: &Self, subpos: usize, sublen: usize)

如果subpos超出范围则不做任何改变.

use hicc_std::string;
let mut s1 = string::from(hicc::cstr!("abc"));
let mut s2 = string::from(hicc::cstr!("de"));
s1.assign_str(&s2, 0, string::npos);
assert_eq!(s1.as_cstr(), hicc::cstr!("de"));

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

如果pos超出范围则不做任何改变.

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.erase(1, 1);
assert_eq!(s.as_cstr(), hicc::cstr!("ac"));

pub fn pop_back(&mut self)

如果为空则不做任何改变.

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.pop_back();
assert_eq!(s.as_cstr(), hicc::cstr!("ab"));

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

use hicc_std::string;
let s = string::from(hicc::cstr!("abc"));
assert_eq!(s.get(0), Some(&(b'a' as i8)));
assert_eq!(s.get(3), None);

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

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
assert!(s.get_mut(0).is_some());
assert_eq!(*s.get_mut(0).unwrap(), b'a' as i8);
assert_eq!(s.get(3), None);

pub fn c_str( &self, ) -> <CharT as AbiType>::OutputPtr<'static, *const <CharT as AbiType>::InputType, 1usize>

use std::ffi::CStr;
use hicc_std::string;
let s = string::from(hicc::cstr!("abc"));
let cstr = unsafe { CStr::from_ptr(s.c_str()) };
assert_eq!(cstr, hicc::cstr!("abc"));

pub fn is_empty(&self) -> bool

use hicc_std::string;
let s = string::new();
assert!(s.is_empty());

pub fn size(&self) -> usize

use hicc_std::string;
let s = string::new();
assert_eq!(s.size(), 0);

pub fn max_size(&self) -> usize

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

pub fn capacity(&self) -> usize

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

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

use hicc_std::string;
let mut s = string::from(hicc::cstr!("a"));
s.resize(3, b'c' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("acc"));

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

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.reserve(100);
println!("s.capacity = {}", s.capacity());

pub fn clear(&mut self)

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.clear();
assert!(s.is_empty());

pub fn shrink_to_fit(&mut self)

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.reserve(100);
println!("before shrink_to_fit: capacity = {}", s.capacity());
s.assign(10, b'c' as i8);
s.shrink_to_fit();
println!("after shrink_to_fit: capacity = {}", s.capacity());

pub fn compare( &self, other: &<basic_string<CharT> as AbiType>::InputType, ) -> i32

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abc"));
let s2 = string::from(hicc::cstr!("abd"));
assert!(s1 < s2);
assert!(s1 != s2);

pub fn find_str( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("bcd"));
assert_eq!(s1.find_str(&s2, 0), 1);

pub fn find(&self, c: <CharT as AbiType>::InputType, pos: usize) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcdef"));
assert_eq!(s.find(b'c' as i8, 1), 2);

pub fn rfind_str( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("bcd"));
assert_eq!(s1.rfind_str(&s2, string::npos), 1);

pub fn rfind(&self, c: <CharT as AbiType>::InputType, pos: usize) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcdef"));
assert_eq!(s.rfind(b'c' as i8, string::npos), 2);

pub fn find_first_of( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("dfb"));
assert_eq!(s1.find_first_of(&s2, 0), 1);

pub fn find_first(&self, c: <CharT as AbiType>::InputType, pos: usize) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcabc"));
assert_eq!(s.find_first(b'c' as i8, 0), 2);

pub fn find_last_of( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("dfb"));
assert_eq!(s1.find_last_of(&s2, string::npos), 5);

pub fn find_last(&self, c: <CharT as AbiType>::InputType, pos: usize) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcabc"));
assert_eq!(s.find_last(b'c' as i8, string::npos), 5);

pub fn find_first_not_of( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("abc"));
assert_eq!(s1.find_first_not_of(&s2, 0), 3);

pub fn find_first_not( &self, c: <CharT as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcabc"));
assert_eq!(s.find_first_not(b'a' as i8, 0), 1);

pub fn find_last_not_of( &self, target: &<basic_string<CharT> as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s1 = string::from(hicc::cstr!("abcdef"));
let s2 = string::from(hicc::cstr!("def"));
assert_eq!(s1.find_last_not_of(&s2, string::npos), 2);

pub fn find_last_not( &self, c: <CharT as AbiType>::InputType, pos: usize, ) -> usize

use hicc_std::string;
let s = string::from(hicc::cstr!("abcabc"));
assert_eq!(s.find_last_not(b'c' as i8, string::npos), 4);

pub fn append(&mut self, n: usize, c: <CharT as AbiType>::InputType)

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.append(1, b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("abcd"));

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

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.assign(1, b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("d"));

pub fn push_back(&mut self, c: <CharT as AbiType>::InputType)

use hicc_std::string;
let mut s = string::from(hicc::cstr!("abc"));
s.push_back(b'd' as i8);
assert_eq!(s.as_cstr(), hicc::cstr!("abcd"));

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

use hicc_std::string;
let mut s1 = string::from(hicc::cstr!("abc"));
let mut s2 = string::from(hicc::cstr!("de"));
s1.swap(&mut s2);
assert_eq!(s1.as_cstr(), hicc::cstr!("de"));
assert_eq!(s2.as_cstr(), hicc::cstr!("abc"));

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

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

use hicc_std::string;
let mut s = string::with_cstr(hicc::cstr!("bcd"));
assert_eq!(s.as_slice(), &[b'b' as i8, b'c' as i8, b'd' as i8]);

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

use hicc_std::string;
let mut s = string::with_cstr(hicc::cstr!("abc"));
s.as_slice_mut().iter_mut().for_each(|mut c| { *c += 1; });
assert_eq!(s.as_slice(), &[b'b' as i8, b'c' as i8, b'd' as i8]);

impl basic_string<Pod<i8>>

pub fn with_buf(b: &[u8]) -> Self

pub fn as_buf(&self) -> &[u8]

pub fn as_cstr(&self) -> &CStr

impl basic_string<Pod<i16>>

pub fn with_buf(b: &[u16]) -> Self

pub fn as_buf(&self) -> &[u16]

impl basic_string<Pod<i32>>

pub fn with_buf(b: &[u32]) -> Self

pub fn as_buf(&self) -> &[u32]

impl basic_string<Pod<i8>>

pub fn new() -> <string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::string> hicc::make_unique<std::string>()

impl basic_string<Pod<i8>>

pub fn with_cstr(s: &CStr) -> <string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::string> hicc::make_unique<std::string, const char*>(const char* &&)

impl basic_string<Pod<i8>>

pub unsafe fn with_cbuf( s: *const u8, len: usize, ) -> <string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::string> hicc::make_unique<std::string, const char*, size_t>(const char* &&, size_t&&)

impl basic_string<Pod<i16>>

pub fn new() -> <u16string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::u16string> hicc::make_unique<std::u16string>()

impl basic_string<Pod<i16>>

pub unsafe fn with_cbuf( s: *const u16, len: usize, ) -> <u16string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::u16string> hicc::make_unique<std::u16string, const char16_t*, size_t>(const char16_t* &&, size_t&&)

impl basic_string<Pod<i32>>

pub fn new() -> <u32string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::u32string> hicc::make_unique<std::u32string>()

impl basic_string<Pod<i32>>

pub unsafe fn with_cbuf( s: *const u32, len: usize, ) -> <u32string as AbiType>::OutputType

cpp global function: std::unique_ptr<std::u32string> hicc::make_unique<std::u32string, const char32_t*, size_t>(const char32_t* &&, size_t&&)

Trait Implementations

impl<CharT: AbiType + 'static> AbiClass for basic_string<CharT>

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

仅内部使用.返回原始指针，等同于c++侧的指针。

fn get_level(&self) -> usize

仅内部使用.返回指针的重数(0表示对象本身, 1表示一重指针, …)。

unsafe fn make_ref(&self, obj: *const (), level: usize) -> 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>

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

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

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<CharT: AbiType + 'static> Debug for basic_string<CharT>

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

Formats the value using the given formatter.

impl<CharT: AbiType + 'static> Drop for basic_string<CharT>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: AbiType> PartialEq for basic_string<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: AbiType> PartialOrd for basic_string<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<CharT: AbiType + Sync> Send for basic_string<CharT>

impl<CharT: AbiType + Sync> Sync for basic_string<CharT>