Struct CSliceMut

Source

pub struct CSliceMut<'a, T> { /* private fields */ }

Expand description

The type representing an ‘unsafe’ mutable foreign chunk of memory.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };

Implementations§

Source §

impl<'a, T> CSliceMut<'a, T>

Source

pub unsafe fn new(base: *mut T, len: usize) -> CSliceMut<'a, T>

Create a CSlice from a raw pointer to a buffer with a given length.

Panics if the given pointer is null. The returned slice will not attempt to deallocate the slice when dropped.

§Arguments

base - A raw pointer to a buffer
len - The number of elements in the buffer

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };

Source

pub fn get(&self, ofs: usize) -> Option<&T>

Retrieves an element at a given index, returning None if the requested index is greater than the length of the slice.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
assert_eq!(cslice.get(1), slice.get(1));

Source

pub unsafe fn get_unchecked(&self, ofs: usize) -> &T

Returns a reference to an element without doing any check.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
unsafe {
    assert_eq!(cslice.get_unchecked(1), slice.get_unchecked(1));
}

Source

pub fn get_mut(&mut self, ofs: usize) -> Option<&mut T>

Retrieves a mutable element at a given index, returning None if the requested index is greater than the length of the slice.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let mut cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
if let Some(el) = cslice.get_mut(1) {
    *el += 10;
}
assert_eq!(cslice[1], 11);

Source

pub unsafe fn get_unchecked_mut(&mut self, ofs: usize) -> &mut T

Returns a mutable reference to an element without doing any check.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let mut cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
unsafe { *cslice.get_unchecked_mut(1) += 10; }
assert_eq!(cslice[1], 11);

Source

pub fn len(&self) -> usize

Returns the number of items in this slice.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
assert_eq!(cslice.len(), slice.len());

Source

pub fn is_empty(&self) -> bool

Returns whether this slice is empty.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
assert_eq!(cslice.is_empty(), slice.is_empty());

Source

pub fn iter<'b>(&'b self) -> CSliceMutIter<'a, 'b, T> ⓘ

Returns an iterator over CSliceMut.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
for elem in cslice.iter() {
    println!("=> {}", elem);
}

Source

pub fn iter_mut<'b>(&'b mut self) -> CSliceMutIterMut<'a, 'b, T> ⓘ

Returns a mutable iterator over CSliceMut.

§Example

use c_vec::CSliceMut;

let slice = &mut [0, 1, 2];
let ptr = slice.as_mut_ptr();
let mut cslice = unsafe { CSliceMut::new(ptr, slice.len()) };
for elem in cslice.iter_mut() {
    *elem += 1;
}
assert_eq!(cslice[0], 1);