Struct clang_sys::CXIndexAction

pub struct CXIndexAction(pub *mut c_void);

Methods from Deref<Target=*mut c_void>

fn is_null(self) -> bool

Returns true if the pointer is null.

Examples

Basic usage:

let s: &str = "Follow the rabbit";
let ptr: *const u8 = s.as_ptr();
assert!(!ptr.is_null());

unsafe fn as_ref(self) -> Option<&'a T>

Returns None if the pointer is null, or else returns a reference to the value wrapped in Some.

Safety

While this method and its mutable counterpart are useful for null-safety, it is important to note that this is still an unsafe operation because the returned value could be pointing to invalid memory.

Additionally, the lifetime 'a returned is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.

Examples

Basic usage:

let val: *const u8 = &10u8 as *const u8;

unsafe {
    if let Some(val_back) = val.as_ref() {
        println!("We got back the value: {}!", val_back);
    }
}

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

Calculates the offset from a pointer. count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * sizeof::<T>() bytes.

Safety

Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object. If either pointer is out of bounds or arithmetic overflow occurs then any further use of the returned value will result in undefined behavior.

Examples

Basic usage:

let s: &str = "123";
let ptr: *const u8 = s.as_ptr();

unsafe {
    println!("{}", *ptr.offset(1) as char);
    println!("{}", *ptr.offset(2) as char);
}

fn wrapping_offset(self, count: isize) -> *const T

Unstable (ptr_wrapping_offset)

Calculates the offset from a pointer using wrapping arithmetic. count is in units of T; e.g. a count of 3 represents a pointer offset of 3 * sizeof::<T>() bytes.

Safety

The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).

Always use .offset(count) instead when possible, because offset allows the compiler to optimize better.

Examples

Basic usage:

#![feature(ptr_wrapping_offset)]
// Iterate using a raw pointer in increments of two elements
let data = [1u8, 2, 3, 4, 5];
let mut ptr: *const u8 = data.as_ptr();
let step = 2;
let end_rounded_up = ptr.wrapping_offset(6);

// This loop prints "1, 3, 5, "
while ptr != end_rounded_up {
    unsafe {
        print!("{}, ", *ptr);
    }
    ptr = ptr.wrapping_offset(step);
}

Trait Implementations

impl Copy for CXIndexAction

impl Clone for CXIndexAction

fn clone(&self) -> CXIndexAction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CXIndexAction

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for CXIndexAction

fn default() -> CXIndexAction

Returns the "default value" for a type.

impl Deref for CXIndexAction

type Target = *mut c_void

The resulting type after dereferencing

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

The method called to dereference a value