Module ptr

Trait Ptr

fn is_null(&const self) -> bool

fn is_not_null(&const self) -> bool

fn offset(&self, count: uint) -> Self

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

Extension methods for immutable pointers

fn is_null(&const self) -> bool

fn is_not_null(&const self) -> bool

fn offset(&self, count: uint) -> *T

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

Extension methods for mutable pointers

fn is_null(&const self) -> bool

fn is_not_null(&const self) -> bool

fn offset(&self, count: uint) -> *mut T

Implementation of Eq for *const T where <T>

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

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

Implementation of Ord for *const T where <T>

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

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

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

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

Implementation of Eq for &'self const T where <'self, T: Eq>

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

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

Implementation of Ord for &'self const T where <'self, T: Ord>

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

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

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

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

Function addr_of

fn addr_of<T>(val: &T) -> *T

Get an unsafe pointer to a value

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-dodgey 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 const_offset

fn const_offset<T>(ptr: *const T, count: uint) -> *const T

Calculate the offset from a const pointer

Function copy_memory

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

Function is_not_null

fn is_not_null<T>(ptr: *const T) -> bool

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

Function is_null

fn is_null<T>(ptr: *const T) -> 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

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

Calculate the offset from a mut pointer

Function null

fn null<T>() -> *T

Create an unsafe null pointer

Function offset

fn offset<T>(ptr: *T, count: uint) -> *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 ref_eq

fn ref_eq<'a, 'b, T>(thing: &'a T, other: &'b T) -> bool

Determine if two borrowed pointers point to the same thing.

Function set_memory

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

Function to_const_unsafe_ptr

fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T

Transform a const region pointer - &const T - to a const unsafe pointer - *const T. This is safe, but is implemented with an unsafe block due to reinterpret_cast.

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. This is safe, but is implemented with an unsafe block due to reinterpret_cast.

Function to_uint

fn to_uint<T>(thing: &T) -> uint

Cast a region pointer - &T - to a uint. This is safe, but is implemented with an unsafe block due to reinterpret_cast.

(I couldn't think of a cutesy name for this one.)

Function to_unsafe_ptr

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

Transform a region pointer - &T - to an unsafe pointer - *T. This is safe, but is implemented with an unsafe block due to reinterpret_cast.