Struct sentinel::SBox

pub struct SBox<T: Sentinel, A: Allocator = Global> { /* private fields */ }

An allocated SSlice<T> instance.

Implementations

impl<T: Sentinel, A: Allocator> SBox<T, A>

pub fn from_sslice_in( slice: &SSlice<T>, allocator: A ) -> Result<Self, AllocError>

where T: Clone,

Clones the content of slice into a SBox<T>.

pub unsafe fn from_slice_unchecked_in( slice: &[T], allocator: A ) -> Result<Self, AllocError>

where T: Clone,

Creates a new SBox<T> from the provided slice.

Safety

slice must end with a sentinel value. Apart from this one, it must contain no sentinel values.

pub fn from_slice_in(slice: &[T], allocator: A) -> Result<Self, AllocError>

where T: Clone,

Creates a new SBox<T, A> from the provided slice.

If the slice contains a sentinel value, the procuded SBox<T> will only clone the values up to that point. If the slice contains no sentinel value, a default sentinel value will be used instead (see [DefaultSentinel]).

pub fn into_raw_parts(b: SBox<T, A>) -> (*mut T, A)

Turns the provided SBox<T> into its raw representation.

The returned pointer can be used to re-construct a box using from_raw_parts.

pub unsafe fn from_raw_parts(data: *mut T, allocator: A) -> Self

Constructs a new SBox<T> using the provided data pointer and allocator.

Safety

The provided pointer must reference the first element of a SSlice<T> instance allocated by allocator.

impl<T: Sentinel> SBox<T, Global>

pub fn from_sslice(slice: &SSlice<T>) -> Result<Self, AllocError>

where T: Clone,

Clones the content of slice into a SBox<T>.

pub fn from_slice(slice: &[T]) -> Result<Self, AllocError>

where T: Clone,

Clones the content of slice into a SBox<T>.

If the provided slice contains a sentinel value, the produced box will contain values up to that point. Otherwise, a default sentinel value will be used (see [DefaultSentinel]).

pub unsafe fn from_box_unchecked(b: Box<[T]>) -> Self

Creates a SBox<T> from the provided allocated box.

Safety

The last element of the slice must be a sentinel, and other elements must not.

pub fn from_box(b: Box<[T]>) -> Option<Self>

Creates an SBox<T> from the provided allocated box.

If the box does not end with a sentinel value, or if it contains a sentinel value in non-ending position, None is returned.

Methods from Deref<Target = SSlice<T>>

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

Returns a pointer to the first element that is part of the slice.

Notes

This pointer is always valid and will reference an initialized instance of T. Note, however, that this value cannot be modified (even if it supports interior mutability). Or, rather, if it is a sentinel, it must remain a sentinel.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a pointer to the first element that is part of the slice.

Notes

This pointer is always valid and will reference an initialized instance of T. Note, however, that this value cannot be modified. Or, rather, if it is a sentinel, it must remain a sentinel.

pub fn iter(&self) -> &Iter<T>

Returns an iterator over the elements of the slice.

Examples

let s = sentinel::cstr!("Hello!");
let mut iter = s.iter();

assert_eq!(iter.next(), Some(&b'H'));
assert_eq!(iter.next(), Some(&b'e'));
assert_eq!(iter.next(), Some(&b'l'));
assert_eq!(iter.next(), Some(&b'l'));
assert_eq!(iter.next(), Some(&b'o'));
assert_eq!(iter.next(), Some(&b'!'));
assert_eq!(iter.next(), None);

pub fn iter_mut(&mut self) -> &mut Iter<T>

Returns an iterator over the elements of the slice.

Examples

let mut array = *b"abc\0";
let mut sslice = sentinel::SSlice::<u8>::from_slice_mut(&mut array).unwrap();
let mut iter = sslice.iter_mut();

*iter.next().unwrap() = b'1';
*iter.next().unwrap() = b'2';
*iter.next().unwrap() = b'3';

assert_eq!(sslice, b"123");

pub unsafe fn get_unchecked<Idx>(&self, index: Idx) -> &Idx::Output

where Idx: SliceIndex<T>,

Indexes into this SSlice<T> instance without checking the bounds.

Safety

index must be in bounds.

pub unsafe fn get_unchecked_mut<Idx>(&mut self, index: Idx) -> &mut Idx::Output

where Idx: SliceIndex<T>,

Indexes into this SSlice<T> instance without checking the bounds.

Safety

index must be in bounds.

pub fn len(&self) -> usize

Returns the length of the SSlice<T>. This is the number of elements referenced by that instance, not including the terminating sentinel character.

Examples

use sentinel::SSlice;

let sslice = SSlice::<u8>::from_slice(b"Hello\0World").unwrap();
assert_eq!(sslice.len(), 5);

pub fn is_empty(&self) -> bool

Returns whether the slice is currently empty.

Examples

use sentinel::SSlice;

assert!(!SSlice::<u8>::from_slice(b"123\0").unwrap().is_empty());
assert!(SSlice::<u8>::from_slice(b"\0").unwrap().is_empty());

pub fn first(&self) -> Option<&T>

Returns the first element of the slice, or None if it is empty.

Examples

use sentinel::SSlice;

assert_eq!(SSlice::<u8>::from_slice(b"123\0").unwrap().first(), Some(&b'1'));
assert_eq!(SSlice::<u8>::from_slice(b"\0").unwrap().first(), None);

pub fn first_mut(&mut self) -> Option<&mut T>

Returns the first element of the slice, or None if it is empty.

Examples

use sentinel::SSlice;

let mut array = [1, 2, 3, 0];
let mut sslice = SSlice::<u8>::from_slice_mut(&mut array).unwrap();

*sslice.first_mut().unwrap() = 0;

assert_eq!(sslice.first_mut(), None);

pub fn split_first(&self) -> Option<(&T, &Self)>

Returns a pointer to the first element of the slice, and a slice to the remaining elements. None is returned if the slice is empty.

Examples

use sentinel::SSlice;

let sslice = SSlice::<u8>::from_slice(b"1234\0").unwrap();
let (first, remainder) = sslice.split_first().unwrap();
assert_eq!(*first, '1' as u8);
assert_eq!(remainder, b"234");

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut Self)>

Returns a pointer to the first element of the slice, and a slice to the remaining elements. None is returned if the slice is empty.

Examples

use sentinel::SSlice;

let mut array = *b"1234\0";
let mut sslice = SSlice::<u8>::from_slice_mut(&mut array).unwrap();
let (first, remainder) = sslice.split_first_mut().unwrap();
assert_eq!(*first, '1' as u8);
assert_eq!(remainder, b"234");

*first = 0;

assert!(sslice.is_empty());

pub unsafe fn raw_first(&self) -> &T

Returns a shared reference to the first element of the slice, or a sentinel value if the slice is empty.

Safety

If the returned value is a sentinel, it must not be modified (or rather, it must remain a sentinel).

pub unsafe fn raw_first_mut(&mut self) -> &mut T

Returns an exclusive reference to the first element of the slice, or a sentinel value if the slice is empty.

Safety

If the returned value is a sentinel, it must not be modified (or rather, it must remain a sentinel).

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

Returns a slice referencing every element of this SSlice<T>, not including the terminating sentinel character.

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

Returns a slice referencing every element of this SSlice<T>, not including the terminating sentinel character.

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

Returns a slice referencing every element of this SSlice<T>, including the terminating sentinel character.

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

Returns a slice referencing every element of this SSlice<T>, including the terminating sentinel character.

pub fn as_std_cstr(&self) -> &CStr

Turns this SSlice<T> into a standard core::ffi::CStr.

pub fn display(&self) -> &Display

An implementation of fmt::Display and fmt::Debug for the CStr type.

When an invalid character is found, the REPLACEMENT_CHARACTER is displayed instead.

Trait Implementations

impl<T: Sentinel, A: Allocator> AsMut<SSlice<T>> for SBox<T, A>

fn as_mut(&mut self) -> &mut SSlice<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Sentinel, A: Allocator> AsRef<SSlice<T>> for SBox<T, A>

fn as_ref(&self) -> &SSlice<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Sentinel, A: Allocator> Borrow<SSlice<T>> for SBox<T, A>

fn borrow(&self) -> &SSlice<T>

Immutably borrows from an owned value.

impl<T: Sentinel, A: Allocator> BorrowMut<SSlice<T>> for SBox<T, A>

fn borrow_mut(&mut self) -> &mut SSlice<T>

Mutably borrows from an owned value.

impl<T, A> Clone for SBox<T, A>

where T: Clone + Sentinel, A: Allocator + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Sentinel, A: Allocator> Deref for SBox<T, A>

type Target = SSlice<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Sentinel, A: Allocator> DerefMut for SBox<T, A>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Sentinel, A: Allocator> Drop for SBox<T, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Sentinel> FromIterator<T> for SBox<T, Global>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a new SBox<T> from the values returned by the provided iterator. If a sentinel value is returned, it is ignored.

impl<T, A> Ord for SBox<T, A>

where A: Allocator, T: Ord + Sentinel,

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 + PartialOrd,

Restrict a value to a certain interval.

impl<T, T2, A> PartialEq<SBox<T, A>> for [T2]

where T: Sentinel, A: Allocator, T2: PartialEq<T>,

fn eq(&self, other: &SBox<T, A>) -> bool

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

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

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

impl<T, T2, A, const N: usize> PartialEq<SBox<T, A>> for [T2; N]

where T: Sentinel, A: Allocator, T2: PartialEq<T>,

fn eq(&self, other: &SBox<T, A>) -> bool

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

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

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

impl<T, T2, A> PartialEq<SBox<T, A>> for SSlice<T2>

where T: Sentinel, T2: Sentinel + PartialEq<T>, A: Allocator,

fn eq(&self, other: &SBox<T, A>) -> bool

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

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

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

impl<T, U, A> PartialEq<U> for SBox<T, A>

where A: Allocator, T: Sentinel, SSlice<T>: PartialEq<U>,

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

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

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

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

impl<T, T2, A> PartialOrd<SBox<T, A>> for [T2]

where T: Sentinel, A: Allocator, T2: PartialOrd<T>,

fn partial_cmp(&self, other: &SBox<T, A>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, T2, A, const N: usize> PartialOrd<SBox<T, A>> for [T2; N]

where T: Sentinel, A: Allocator, T2: PartialOrd<T>,

fn partial_cmp(&self, other: &SBox<T, A>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, T2, A> PartialOrd<SBox<T, A>> for SSlice<T2>

where T: Sentinel, T2: Sentinel + PartialOrd<T>, A: Allocator,

fn partial_cmp(&self, other: &SBox<T, A>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, U, A> PartialOrd<U> for SBox<T, A>

where A: Allocator, T: Sentinel, SSlice<T>: PartialOrd<U>,

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

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

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

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

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

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

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

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

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

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

impl<T, A> Eq for SBox<T, A>

where A: Allocator, T: Eq + Sentinel,