Struct BSString

#[repr(C)]
pub struct BSString<A = TESGlobalAlloc>
where
    A: SelflessAllocator,
{ /* private fields */ }

BSString represents a string that stores its data as raw bytes from FFI with an undefined encoding.

It provides methods for managing the string’s data and converting it to/from CStr. This struct is designed for situations where string encoding isn’t guaranteed, such as when dealing with FFI.

Encoding

It has been confirmed that this string is also UTF-8 when esp. etc. are saved in UTF-8.

Examples

let mut bs = BSString::new();
assert_eq!(bs.len(), 0);

bs.set_c_str(&c"Hello, Rust!");
assert_eq!(bs.len(), 13);
assert_eq!(bs.as_c_str().to_str(), Ok("Hello, Rust!"));

Implementations

impl BSString

pub const fn new() -> Self

Creates a new BSString instance with no data.

Examples

let bs = BSString::new();
assert_eq!(bs.len(), 0);

impl<A> BSString<A>

where A: SelflessAllocator,

pub const fn new_in() -> Self

Creates a new, empty BSString.

Examples

use commonlibsse_ng::re::BSString::BSString;
use stdx::alloc::Global;

let bs = BSString::<Global>::new_in();
assert!(bs.is_empty());

pub fn from_c_str(s: &CStr) -> Result<Self, BSStringError>

Allocate a new Self from &CStr argument.

Examples

use stdx::alloc::Global;
let bs = BSString::<Global>::from_c_str(c"Hello").unwrap();
assert_eq!(bs.as_c_str(), c"Hello");

Errors

• If the string is too long to fit in a u16, or if allocation fails.
• If allocations fail.

pub fn clear(&mut self)

Clears the string’s data, resetting its size and capacity.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello, Rust!");
assert!(!bs.is_empty());
bs.clear();
assert!(bs.is_empty());

pub fn set_c_str(&mut self, cstr: &CStr) -> Result<(), BSStringError>

Sets the content of the BSString from a CStr.

This method will overwrite the current data, resizing if necessary.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello, Rust!");
assert_eq!(bs.len(), 13);

Errors

• If the string is too long to fit in a u16, or if allocation fails.
• If allocations fail.

pub const fn is_empty(&self) -> bool

Checks if the string is empty.

Examples

let bs = BSString::new();
assert!(bs.is_empty());

pub const fn len(&self) -> usize

Returns the bytes length of the string.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello"); // Contains `\0`
assert_eq!(bs.len(), 6);

pub const fn capacity(&self) -> u16

Returns the capacity of the string.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello");
assert!(bs.capacity() >= 5);

pub const fn as_bytes_with_null(&self) -> &[u8]

Returns the underlying bytes of the string, including the null terminator.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello");
assert_eq!(bs.as_bytes_with_null(), b"Hello\0");

pub const fn as_c_str(&self) -> &CStr

Returns the string as a CStr, which is suitable for FFI.

Examples

let mut bs = BSString::new();
bs.set_c_str(&c"Hello");
assert_eq!(bs.as_c_str().to_str(), Ok("Hello"));

Trait Implementations

impl<A> Clone for BSString<A>

where A: SelflessAllocator,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A> Debug for BSString<A>

where A: SelflessAllocator,

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

Formats the value using the given formatter.

impl Default for BSString

fn default() -> Self

Returns the “default value” for a type.

impl<A> Drop for BSString<A>

where A: SelflessAllocator,

fn drop(&mut self)

Executes the destructor for this type.

impl<A> Hash for BSString<A>

where A: SelflessAllocator,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A> Ord for BSString<A>

where A: SelflessAllocator,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<A, B> PartialEq<BSString<B>> for BSString<A>

where A: SelflessAllocator, B: SelflessAllocator,

fn eq(&self, other: &BSString<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A> PartialEq<CStr> for BSString<A>

where A: SelflessAllocator,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B> PartialOrd<BSString<B>> for BSString<A>

where A: SelflessAllocator, B: SelflessAllocator,

fn partial_cmp(&self, other: &BSString<B>) -> 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<A: SelflessAllocator> TryFrom<&str> for BSString<A>

type Error = BSStringError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: SelflessAllocator> TryFrom<CString> for BSString<A>

type Error = BSStringError

The type returned in the event of a conversion error.

fn try_from(c_string: CString) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: SelflessAllocator> TryFrom<String> for BSString<A>

type Error = BSStringError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<A> Eq for BSString<A>

where A: SelflessAllocator,