[go: up one dir, main page]

Struct ravif::Img[−][src]

pub struct Img<Container> {
    pub buf: Container,
    pub stride: usize,
    pub width: u32,
    pub height: u32,
}
Expand description

Basic struct used for both owned (alias ImgVec) and borrowed (alias ImgRef) image fragments.

Note: the fields are pub only because of borrow checker limitations. Please consider them as read-only.

Fields

buf: Container
👎 Deprecated:

Don’t access struct fields directly. Use buf(), buf_mut() or into_buf()

Storage for the pixels. Usually Vec<Pixel> or &[Pixel]. See ImgVec and ImgRef.

Note that future version will make this field private. Use .rows() and .pixels() iterators where possible, or buf()/buf_mut()/into_buf().

stride: usize
👎 Deprecated:

Don’t access struct fields directly. Use stride()

Number of pixels to skip in the container to advance to the next row.

Note: pixels between width and stride may not be usable, and may not even exist in the last row.

width: u32
👎 Deprecated:

Don’t access struct fields directly. Use width()

Width of the image in pixels.

Note that this isn’t same as the width of the row in the buf, see stride

height: u32
👎 Deprecated:

Don’t access struct fields directly. Use height()

Height of the image in pixels.

Implementations

impl<Container> Img<Container>[src]

pub fn width(&self) -> usize[src]

Width of the image in pixels.

Note that this isn’t same as the width of the row in image data, see stride()

pub fn height(&self) -> usize[src]

Height of the image in pixels.

pub fn stride(&self) -> usize[src]

Number of pixels to skip in the container to advance to the next row.

Note the last row may have fewer pixels than the stride. Some APIs use number of bytes for a stride. You may need to multiply this one by number of pixels.

pub fn buf(&self) -> &Container[src]

Immutable reference to the pixel storage. Warning: exposes stride. Use pixels() or rows() insetad.

See also into_contiguous_buf().

pub fn buf_mut(&mut self) -> &mut Container[src]

Mutable reference to the pixel storage. Warning: exposes stride. Use pixels_mut() or rows_mut() insetad.

See also into_contiguous_buf().

pub fn into_buf(self) -> Container[src]

Get the pixel storage by consuming the image. Be careful about stride — see into_contiguous_buf() for a safe version.

pub fn rows_buf<'a, T>(&self, buf: &'a [T]) -> RowsIter<'a, T> where
    T: 'a, [src]

👎 Deprecated:

this was meant to be private, use new_buf() and/or rows()

impl<'a, T> Img<&'a [T]>[src]

#[must_use]
pub fn sub_image(
    &self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Img<&'a [T]>[src]

Make a reference for a part of the image, without copying any pixels.

Panics

It will panic if sub_image is outside of the image area (left + width must be <= container width, etc.)

#[must_use]
pub fn rows(&self) -> RowsIter<'_, T>[src]

Iterate over whole rows of pixels as slices

Panics

If stride is 0

See also pixels()

pub fn iter(&self) -> Iter<'_, T>[src]

👎 Deprecated:

Size of this buffer is unpredictable. Use .rows() instead

Deprecated

Note: it iterates all pixels in the underlying buffer, not just limited by width/height.

impl<'a, T> Img<&'a [T]> where
    T: Clone, [src]

#[must_use]
pub fn to_contiguous_buf(&self) -> (Cow<'_, [T]>, usize, usize)[src]

Returns a reference to the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

It will create a copy if the buffer isn’t contiguous (width != stride). For a more efficient version, see into_contiguous_buf()

impl<'a, T> Img<&'a mut [T]>[src]

#[must_use]
pub fn sub_image(
    &'a mut self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Img<&'a [T]>[src]

Turn this into immutable reference, and slice a subregion of it

#[must_use]
pub fn sub_image_mut(
    &mut self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Img<&mut [T]>[src]

Trim this image without copying. Note that mutable borrows are exclusive, so it’s not possible to have more than one mutable subimage at a time.

#[must_use]
pub fn as_ref(&self) -> Img<&[T]>[src]

Make mutable reference immutable

impl<'a, T> Img<&'a [T]> where
    T: Copy, [src]

#[must_use]
pub fn pixels(&self) -> PixelsIter<'_, T>[src]

Iterate width*height pixels in the Img, ignoring padding area

Panics

if width is 0

impl<'a, T> Img<&'a [T]>[src]

#[must_use]
pub fn pixels_ref(&self) -> PixelsRefIter<'_, T>[src]

Iterate width*height pixels in the Img, by reference, ignoring padding area

Panics

if width is 0

impl<'a, T> Img<&'a mut [T]> where
    T: Copy, [src]

#[must_use]
pub fn pixels(&self) -> PixelsIter<'_, T>[src]

Panics

if width is 0

#[must_use]
pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>[src]

Panics

if width is 0

impl<'a, T> Img<Vec<T, Global>> where
    T: Copy, [src]

#[must_use]
pub fn pixels(&self) -> PixelsIter<'_, T>[src]

Panics

if width is 0

#[must_use]
pub fn pixels_mut(&mut self) -> PixelsIterMut<'_, T>[src]

Panics

if width is 0

impl<'a, T> Img<&'a mut [T]>[src]

#[must_use]
pub fn rows(&self) -> RowsIter<'_, T>[src]

Panics

if stride is 0

#[must_use]
pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>[src]

Panics

if stride is 0

impl<T> Img<Vec<T, Global>>[src]

#[must_use]
pub fn sub_image_mut(
    &mut self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Img<&mut [T]>[src]

Create a mutable view into a region within the image. See sub_image() for read-only views.

#[must_use]
pub fn sub_image(
    &self,
    left: usize,
    top: usize,
    width: usize,
    height: usize
) -> Img<&[T]>[src]

Make a reference for a part of the image, without copying any pixels.

#[must_use]
pub fn as_ref(&self) -> Img<&[T]>[src]

Make a reference to this image to pass it to functions without giving up ownership

The reference should be passed by value (ImgRef, not &ImgRef).

If you need a mutable reference, see as_mut() and sub_image_mut()

pub fn as_mut(&mut self) -> Img<&mut [T]>[src]

Make a mutable reference to the entire image

The reference should be passed by value (ImgRefMut, not &mut ImgRefMut).

See also sub_image_mut() and rows_mut()

pub fn iter(&self) -> Iter<'_, T>[src]

👎 Deprecated:

Size of this buffer may be unpredictable. Use .rows() instead

#[must_use]
pub fn rows(&self) -> RowsIter<'_, T>[src]

Iterate over rows of the image as slices

Each slice is guaranteed to be exactly width pixels wide.

#[must_use]
pub fn rows_mut(&mut self) -> RowsIterMut<'_, T>[src]

Iterate over rows of the image as mutable slices

Each slice is guaranteed to be exactly width pixels wide.

impl<Container> Img<Container>[src]

pub fn new_stride(
    buf: Container,
    width: usize,
    height: usize,
    stride: usize
) -> Img<Container>[src]

Same as new(), except each row is located stride number of pixels after the previous one.

Stride can be equal to width or larger. If it’s larger, then pixels between end of previous row and start of the next are considered a padding, and may be ignored.

The Container is usually a Vec or a slice.

pub fn new(buf: Container, width: usize, height: usize) -> Img<Container>[src]

Create new image with Container (which can be Vec, &[] or something else) with given width and height in pixels.

Assumes the pixels in container are contiguous, layed out row by row with width pixels per row and at least height rows.

If the container is larger than width×height pixels, the extra rows are a considered a padding and may be ignored.

impl<T> Img<Vec<T, Global>> where
    T: Copy, [src]

#[must_use]
pub fn into_contiguous_buf(self) -> (Vec<T, Global>, usize, usize)[src]

Returns the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

Efficiently performs operation in-place. For other containers use pixels().collect().

#[must_use]
pub fn as_contiguous_buf(&mut self) -> (&[T], usize, usize)[src]

Returns a reference to the buffer, width, height. Guarantees that the buffer is contiguous, i.e. it’s width*height elements long, and [x + y*width] addresses each pixel.

Efficiently performs operation in-place. For other containers use pixels().collect().

impl<OldContainer> Img<OldContainer>[src]

pub fn new_buf<NewContainer, OldPixel, NewPixel>(
    &self,
    new_buf: NewContainer
) -> Img<NewContainer> where
    OldContainer: AsRef<[OldPixel]>,
    NewContainer: AsRef<[NewPixel]>, [src]

A convenience method for creating an image of the same size and stride, but with a new buffer.

impl<'_, T> Img<Cow<'_, [T]>> where
    T: Clone, [src]

pub fn into_owned(self) -> Img<Vec<T, Global>>[src]

Convert underlying buffer to owned (e.g. slice to vec)

See also to_contiguous_buf().0.into_owned()

impl<T> Img<T> where
    T: ToOwned, [src]

pub fn to_owned(&self) -> Img<<T as ToOwned>::Owned>[src]

Convert underlying buffer to owned (e.g. slice to vec)

See also to_contiguous_buf().0.into_owned()

Trait Implementations

impl<Container> Clone for Img<Container> where
    Container: Clone, [src]

pub fn clone(&self) -> Img<Container>[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<Container> Debug for Img<Container> where
    Container: Debug, [src]

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>[src]

Formats the value using the given formatter. Read more

impl<'a, T> From<Img<&'a [T]>> for Img<Cow<'a, [T]>> where
    T: Clone, [src]

pub fn from(img: Img<&'a [T]>) -> Img<Cow<'a, [T]>>[src]

Performs the conversion.

impl<'_, T> From<Img<Cow<'_, [T]>>> for Img<Vec<T, Global>> where
    T: Clone, [src]

pub fn from(img: Img<Cow<'_, [T]>>) -> Img<Vec<T, Global>>[src]

Performs the conversion.

impl<T> From<Img<Vec<T, Global>>> for Img<Cow<'static, [T]>> where
    T: Clone, [src]

pub fn from(img: Img<Vec<T, Global>>) -> Img<Cow<'static, [T]>>[src]

Performs the conversion.

impl<T> Hash for Img<Vec<T, Global>> where
    T: Hash, [src]

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, [src]

Feeds this value into the given Hasher. Read more

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

Feeds a slice of this type into the given Hasher. Read more

impl<'a, T> Hash for Img<&'a [T]> where
    T: Hash, [src]

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, [src]

Feeds this value into the given Hasher. Read more

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

Feeds a slice of this type into the given Hasher. Read more

impl<'a, T> Hash for Img<&'a mut [T]> where
    T: Hash, [src]

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, [src]

Feeds this value into the given Hasher. Read more

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

Feeds a slice of this type into the given Hasher. Read more

impl<Pixel, Container> ImgExt<Pixel> for Img<Container> where
    Container: AsRef<[Pixel]>, [src]

pub fn rows_padded(&self) -> Chunks<'_, Pixel>[src]

Iterate over the entire buffer as rows, including all padding

Rows will have up to stride width, but the last row may be shorter.

pub fn width_padded(&self) -> usize[src]

Maximum possible width of the data, including the stride. Read more

pub fn height_padded(&self) -> usize[src]

Height in number of full strides. If the underlying buffer is not an even multiple of strides, the last row is ignored. Read more

pub fn as_ref(&self) -> Img<&[Pixel]>[src]

Borrow the container

impl<Pixel, Container> ImgExtMut<Pixel> for Img<Container> where
    Container: AsMut<[Pixel]>, [src]

#[must_use]
pub fn rows_padded_mut(&mut self) -> ChunksMut<'_, Pixel>[src]

Iterate over the entire buffer as rows, including all padding

Rows will have up to stride width, but the last row may be shorter.

Panics

If stride is 0

pub fn as_mut(&mut self) -> Img<&mut [Pixel]>[src]

Borrow the container mutably

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a [Pixel]> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (u32, u32)
) -> &<Img<&'a [Pixel]> as Index<(u32, u32)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<(u32, u32)> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (u32, u32)
) -> &<Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<(u32, u32)> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (u32, u32)
) -> &<Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<(usize, usize)> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (usize, usize)
) -> &<Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a [Pixel]> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (usize, usize)
) -> &<Img<&'a [Pixel]> as Index<(usize, usize)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<(usize, usize)> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    index: (usize, usize)
) -> &<Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output[src]

Read a pixel at (x,y) location (e.g. px = img[(x,y)])

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

type Output = Pixel

The returned type after indexing.

impl<'a, Pixel> Index<usize> for Img<&'a [Pixel]> where
    Pixel: Copy, [src]

pub fn index(&self, row: usize) -> &<Img<&'a [Pixel]> as Index<usize>>::Output[src]

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

impl<'a, Pixel> Index<usize> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    row: usize
) -> &<Img<&'a mut [Pixel]> as Index<usize>>::Output[src]

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

impl<'a, Pixel> Index<usize> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index(
    &self,
    row: usize
) -> &<Img<Vec<Pixel, Global>> as Index<usize>>::Output[src]

Take n-th row as a slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

type Output = [Pixel]

The returned type after indexing.

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    index: (u32, u32)
) -> &mut <Img<&'a mut [Pixel]> as Index<(u32, u32)>>::Output[src]

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

impl<'a, Pixel> IndexMut<(u32, u32)> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    index: (u32, u32)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(u32, u32)>>::Output[src]

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    index: (usize, usize)
) -> &mut <Img<Vec<Pixel, Global>> as Index<(usize, usize)>>::Output[src]

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

impl<'a, Pixel> IndexMut<(usize, usize)> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    index: (usize, usize)
) -> &mut <Img<&'a mut [Pixel]> as Index<(usize, usize)>>::Output[src]

Write a pixel at (x,y) location (e.g. img[(x,y)] = px)

Coordinates may be outside width/height if the buffer has enough padding. The x coordinate can’t exceed stride.

impl<'a, Pixel> IndexMut<usize> for Img<Vec<Pixel, Global>> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    row: usize
) -> &mut <Img<Vec<Pixel, Global>> as Index<usize>>::Output[src]

Take n-th row as a mutable slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

impl<'a, Pixel> IndexMut<usize> for Img<&'a mut [Pixel]> where
    Pixel: Copy, [src]

pub fn index_mut(
    &mut self,
    row: usize
) -> &mut <Img<&'a mut [Pixel]> as Index<usize>>::Output[src]

Take n-th row as a mutable slice. Same as .rows().nth(n).unwrap()

Slice length is guaranteed to equal image width. Row must be within image height.

impl<Container> IntoIterator for Img<Container> where
    Container: IntoIterator, [src]

Deprecated. Use .rows() or .pixels() iterators which are more predictable

pub fn into_iter(self) -> <Container as IntoIterator>::IntoIter[src]

Deprecated. Use .rows() or .pixels() iterators which are more predictable

type Item = <Container as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <Container as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

impl<'a, T, U> PartialEq<Img<&'a [U]>> for Img<Vec<T, Global>> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<&'a [U]>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<'a, 'b, T, U> PartialEq<Img<&'b [U]>> for Img<&'a [T]> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<&'b [U]>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<'a, 'b, T, U> PartialEq<Img<&'b [U]>> for Img<&'a mut [T]> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<&'b [U]>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<'a, 'b, T, U> PartialEq<Img<&'b mut [U]>> for Img<&'a [T]> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<&'b mut [U]>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<'a, 'b, T, U> PartialEq<Img<&'b mut [U]>> for Img<&'a mut [T]> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<&'b mut [U]>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<'a, T, U> PartialEq<Img<Vec<U, Global>>> for Img<&'a [T]> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<Vec<U, Global>>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<T, U> PartialEq<Img<Vec<U, Global>>> for Img<Vec<T, Global>> where
    T: PartialEq<U>, [src]

pub fn eq(&self, other: &Img<Vec<U, Global>>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

impl<Container> Copy for Img<Container> where
    Container: Copy, [src]

impl<'a, T> Eq for Img<&'a mut [T]> where
    T: Eq, [src]

impl<T> Eq for Img<Vec<T, Global>> where
    T: Eq, [src]

impl<'a, T> Eq for Img<&'a [T]> where
    T: Eq, [src]

Auto Trait Implementations

impl<Container> RefUnwindSafe for Img<Container> where
    Container: RefUnwindSafe, 

impl<Container> Send for Img<Container> where
    Container: Send, 

impl<Container> Sync for Img<Container> where
    Container: Sync, 

impl<Container> Unpin for Img<Container> where
    Container: Unpin, 

impl<Container> UnwindSafe for Img<Container> where
    Container: UnwindSafe, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>, [src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> Pointable for T

pub const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

pub unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

pub unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

pub unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.