Struct javascript_lexer::internship::ICStr

pub struct ICStr(_);

Methods

impl ICStr

pub fn new(src: &CStr) -> ICStr

pub fn from_bytes_with_nul(src: &[u8]) -> Result<ICStr, FromBytesWithNulError>

pub fn as_cstr(&self) -> &CStr

Important traits for &'_ mut [u8]

impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]

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

result slice does not contains trailing nul terminator.

Important traits for &'_ mut [u8]

impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]

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

pub fn to_ibytes_with_nul(&self) -> IBytes

pub fn to_istr(&self) -> Result<IStr, Utf8Error>

Methods from Deref<Target = CStr>

pub fn as_ptr(&self) -> *const i8

Returns the inner pointer to this C string.

The returned pointer will be valid for as long as self is, and points to a contiguous region of memory terminated with a 0 byte to represent the end of the string.

WARNING

The returned pointer is read-only; writing to it (including passing it to C code that writes to it) causes undefined behavior.

It is your responsibility to make sure that the underlying memory is not freed too early. For example, the following code will cause undefined behavior when ptr is used inside the unsafe block:

use std::ffi::{CString};

let ptr = CString::new("Hello").expect("CString::new failed").as_ptr();
unsafe {
    // `ptr` is dangling
    *ptr;
}

This happens because the pointer returned by as_ptr does not carry any lifetime information and the CString is deallocated immediately after the CString::new("Hello").expect("CString::new failed").as_ptr() expression is evaluated. To fix the problem, bind the CString to a local variable:

use std::ffi::{CString};

let hello = CString::new("Hello").expect("CString::new failed");
let ptr = hello.as_ptr();
unsafe {
    // `ptr` is valid because `hello` is in scope
    *ptr;
}

This way, the lifetime of the CString in hello encompasses the lifetime of ptr and the unsafe block.

Important traits for &'_ mut [u8]

impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]

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

Converts this C string to a byte slice.

The returned slice will not contain the trailing nul terminator that this C string has.

Note: This method is currently implemented as a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

use std::ffi::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_bytes(), b"foo");

Important traits for &'_ mut [u8]

impl<'_> Write for &'_ mut [u8]impl<'_> Read for &'_ [u8]

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

Converts this C string to a byte slice containing the trailing 0 byte.

This function is the equivalent of to_bytes except that it will retain the trailing nul terminator instead of chopping it off.

Note: This method is currently implemented as a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

use std::ffi::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");

pub fn to_str(&self) -> Result<&str, Utf8Error>

Yields a &str slice if the CStr contains valid UTF-8.

If the contents of the CStr are valid UTF-8 data, this function will return the corresponding &str slice. Otherwise, it will return an error with details of where UTF-8 validation failed.

Note: This method is currently implemented to check for validity after a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.

Examples

use std::ffi::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_str(), Ok("foo"));

pub fn to_string_lossy(&self) -> Cow<str>

Converts a CStr into a Cow<str>.

If the contents of the CStr are valid UTF-8 data, this function will return a Cow::Borrowed([&str]) with the corresponding [&str] slice. Otherwise, it will replace any invalid UTF-8 sequences with U+FFFD REPLACEMENT CHARACTER and return a Cow::Owned(String) with the result.

Note: This method is currently implemented to check for validity after a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.

Examples

Calling to_string_lossy on a CStr containing valid UTF-8:

use std::borrow::Cow;
use std::ffi::CStr;

let c_str = CStr::from_bytes_with_nul(b"Hello World\0")
                 .expect("CStr::from_bytes_with_nul failed");
assert_eq!(c_str.to_string_lossy(), Cow::Borrowed("Hello World"));

Calling to_string_lossy on a CStr containing invalid UTF-8:

use std::borrow::Cow;
use std::ffi::CStr;

let c_str = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
                 .expect("CStr::from_bytes_with_nul failed");
assert_eq!(
    c_str.to_string_lossy(),
    Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
);

Trait Implementations

impl Deref for ICStr

type Target = CStr

The resulting type after dereferencing.

fn deref(&self) -> &CStr

Dereferences the value.

impl Index<RangeFull> for ICStr

type Output = CStr

The returned type after indexing.

fn index(&self, _index: RangeFull) -> &CStr

Performs the indexing (container[index]) operation.

impl AsRef<CStr> for ICStr

fn as_ref(&self) -> &CStr

Performs the conversion.

impl PartialOrd<ICStr> for ICStr

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Borrow<CStr> for ICStr

fn borrow(&self) -> &CStr

Immutably borrows from an owned value.

impl PartialEq<ICStr> for ICStr

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl From<Box<CStr>> for ICStr

fn from(v: Box<CStr>) -> ICStr

Performs the conversion.

impl<'a> From<&'a CStr> for ICStr

fn from(v: &'a CStr) -> ICStr

Performs the conversion.

impl From<CString> for ICStr

fn from(v: CString) -> ICStr

Performs the conversion.

impl From<ICStr> for IBytes

fn from(v: ICStr) -> IBytes

Performs the conversion.

impl Eq for ICStr

impl Default for ICStr

fn default() -> ICStr

Returns the "default value" for a type.

impl Hash for ICStr

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl Clone for ICStr

fn clone(&self) -> ICStr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Ord for ICStr

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Restrict a value to a certain interval.