Module ptr

Trait RawPtr

fn null() -> Self

fn is_null(&self) -> bool

fn is_not_null(&self) -> bool

fn to_uint(&self) -> uint

unsafe fn to_option(&self) -> Option<&T>

unsafe fn offset(self, count: int) -> Self

Implementation of Clone for *T where <T>

fn clone(&self) -> *T

Implementation of RawPtr<T> for *T where <T>

Extension methods for immutable pointers

fn null() -> *T

fn is_null(&self) -> bool

fn is_not_null(&self) -> bool

fn to_uint(&self) -> uint

unsafe fn to_option(&self) -> Option<&T>

unsafe fn offset(self, count: int) -> *T

Implementation of RawPtr<T> for *mut T where <T>

Extension methods for mutable pointers

fn null() -> *mut T

fn is_null(&self) -> bool

fn is_not_null(&self) -> bool

fn to_uint(&self) -> uint

unsafe fn to_option(&self) -> Option<&T>

unsafe fn offset(self, count: int) -> *mut T

Implementation of Eq for *T where <T>

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

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

Implementation of Eq for *mut T where <T>

fn eq(&self, other: &*mut T) -> bool

fn ne(&self, other: &*mut T) -> bool

Implementation of Equiv<*mut T> for *T where <T>

fn equiv(&self, other: &*mut T) -> bool

Implementation of Equiv<*T> for *mut T where <T>

fn equiv(&self, other: &*T) -> bool

Implementation of Ord for *T where <T>

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

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

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

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

Implementation of Ord for *mut T where <T>

fn lt(&self, other: &*mut T) -> bool

fn le(&self, other: &*mut T) -> bool

fn ge(&self, other: &*mut T) -> bool

fn gt(&self, other: &*mut T) -> bool

Function array_each

unsafe fn array_each<T>(arr: **T, cb: &fn(*T))

Given a null-pointer-terminated **T (pointer to an array of pointers), iterate through each *T, passing to the provided callback function

SAFETY NOTE: This will only work with a null-terminated pointer array. Barely less-dodgy Pointer Arithmetic. Dragons be here.

Function array_each_with_len

unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: &fn(*T))

Given a **T (pointer to an array of pointers), iterate through each *T, up to the provided len, passing to the provided callback function

SAFETY NOTE: Pointer-arithmetic. Dragons be here.

Function buf_len

unsafe fn buf_len<T>(buf: **T) -> uint

Return the offset of the first null pointer in buf.

Function copy_memory

unsafe fn copy_memory<T, P: RawPtr<T>>(dst: *mut T, src: P, count: uint)

Copies data from one location to another.

Copies count elements (not bytes) from src to dst. The source and destination may overlap.

Function copy_nonoverlapping_memory

unsafe fn copy_nonoverlapping_memory<T,
                                     P: RawPtr<T>>(dst: *mut T, src: P,
                                                   count: uint)

Copies data from one location to another.

Copies count elements (not bytes) from src to dst. The source and destination may not overlap.

Function is_not_null

fn is_not_null<T, P: RawPtr<T>>(ptr: P) -> bool

Returns true if the pointer is not equal to the null pointer.

Function is_null

fn is_null<T, P: RawPtr<T>>(ptr: P) -> bool

Returns true if the pointer is equal to the null pointer.

Function mut_null

fn mut_null<T>() -> *mut T

Create an unsafe mutable null pointer

Function mut_offset

unsafe fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T

Calculate the offset from a mut pointer. The count must be in bounds or otherwise the loads of this address are undefined.

Function null

fn null<T>() -> *T

Create an unsafe null pointer

Function offset

unsafe fn offset<T>(ptr: *T, count: int) -> *T

Calculate the offset from a pointer

Function position

unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint

Return the first offset i such that f(buf[i]) == true.

Function read_and_zero_ptr

unsafe fn read_and_zero_ptr<T>(dest: *mut T) -> T

Reads the value from *src and nulls it out. This currently prevents destructors from executing.

Function read_ptr

unsafe fn read_ptr<T>(src: *mut T) -> T

Reads the value from *src and returns it. Does not copy *src.

Function replace_ptr

unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T

Replace the value at a mutable location with a new one, returning the old value, without deinitialising or copying either one.

Function set_memory

unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint)

Invokes memset on the specified pointer, setting count * size_of::<T>() bytes of memory starting at dst to c.

Function swap_ptr

unsafe fn swap_ptr<T>(x: *mut T, y: *mut T)

Swap the values at two mutable locations of the same type, without deinitialising or copying either one.

Function to_mut_unsafe_ptr

fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T

Transform a mutable region pointer - &mut T - to a mutable unsafe pointer - *mut T.

Function to_unsafe_ptr

fn to_unsafe_ptr<T>(thing: &T) -> *T

Transform a region pointer - &T - to an unsafe pointer - *T.

Function zero_memory

unsafe fn zero_memory<T>(dst: *mut T, count: uint)

Zeroes out count * size_of::<T> bytes of memory at dst