Struct OwnedPointer

pub struct OwnedPointer<T: FreeForeign + ?Sized> { /* private fields */ }

A RAII pointer that is automatically freed when it goes out of scope.

Implementations

impl<T: FreeForeign + ?Sized> OwnedPointer<T>

pub unsafe fn new(ptr: *mut <T as FreeForeign>::Foreign) -> Self

Return a new OwnedPointer that wraps the pointer ptr.

Safety

The pointer must be valid and live until the returned OwnedPointer is dropped.

pub fn from<U>(x: OwnedPointer<U>) -> Self

where U: FreeForeign<Foreign = <T as FreeForeign>::Foreign> + ?Sized,

Safely create an OwnedPointer from one that has the same freeing function.

let s = "Hello, world!";
let foreign_str = s.clone_to_foreign();
let foreign_string = OwnedPointer::<String>::from(foreign_str);

pub fn into<U>(self) -> OwnedPointer<U>

where U: FreeForeign<Foreign = <T as FreeForeign>::Foreign>,

Safely convert an OwnedPointer into one that has the same freeing function.

let s = "Hello, world!";
let foreign_str = s.clone_to_foreign();
let foreign_string: OwnedPointer<String> = foreign_str.into();

pub fn as_ptr(&self) -> *const <T as FreeForeign>::Foreign

Return the pointer that is stored in the OwnedPointer. The pointer is valid for as long as the OwnedPointer itself.

let s = "Hello, world!";
let foreign = s.clone_to_foreign();
let p = foreign.as_ptr();
let len = unsafe { libc::strlen(p) };
drop(foreign);

pub fn as_mut_ptr(&self) -> *mut <T as FreeForeign>::Foreign

pub fn into_inner(self) -> *mut <T as FreeForeign>::Foreign

Return the pointer that is stored in the OwnedPointer, consuming the OwnedPointer but not freeing the pointer.

let s = "Hello, world!";
let p = s.clone_to_foreign().into_inner();
let len = unsafe { libc::strlen(p) };
// p needs to be freed manually

impl<T: FromForeign> OwnedPointer<T>

pub fn into_native(self) -> T

Convert a C datum to a native Rust object, taking ownership of the pointer or Rust object (same as from_glib_full in glib-rs)

let s = "Hello, world!".to_string();
let foreign = s.clone_to_foreign();
let native: String = unsafe {
    foreign.into_native()
    // foreign is not leaked
};
assert_eq!(s, native);

Trait Implementations

impl<T: FreeForeign + ?Sized> Debug for OwnedPointer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: CloneToForeign + Default> Default for OwnedPointer<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: FreeForeign + ?Sized> Drop for OwnedPointer<T>

fn drop(&mut self)

Executes the destructor for this type.