rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

Use ptr::NonNull in various places

Browse source
This commit is contained in:
Sebastian Dröge 2018-04-01 11:29:15 +03:00
parent b6a80b59fa
commit fca0287dec
6 changed files with 113 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
gstreamer/src/iterator.rs
View file

@ -50,7 +50,7 @@ impl Error for IteratorError {
// Implemented manually so that we can use generics for the item
pub struct Iterator<T> {
iter: *mut ffi::GstIterator,
iter: ptr::NonNull<ffi::GstIterator>,
borrowed: bool,
phantom: PhantomData<T>,
}
@ -492,7 +492,7 @@ impl<T> Drop for Iterator<T> {
fn drop(&mut self) {
if !self.borrowed {
unsafe {
ffi::gst_iterator_free(self.iter);
ffi::gst_iterator_free(self.iter.as_ptr());
}
}
}
@ -545,7 +545,7 @@ impl<'a, T: 'static> glib::translate::ToGlibPtr<'a, *const ffi::GstIterator> for
type Storage = &'a Iterator<T>;
fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstIterator, Self> {
glib::translate::Stash(self.iter, self)
glib::translate::Stash(self.iter.as_ptr(), self)
}
fn to_glib_full(&self) -> *const ffi::GstIterator {
@ -561,7 +561,7 @@ impl<'a, T: 'static> glib::translate::ToGlibPtrMut<'a, *mut ffi::GstIterator> fo
fn to_glib_none_mut(
&'a mut self,
) -> glib::translate::StashMut<'a, *mut ffi::GstIterator, Self> {
glib::translate::StashMut(self.iter, self)
glib::translate::StashMut(self.iter.as_ptr(), self)
}
}
@ -593,12 +593,13 @@ impl<T: StaticType> glib::translate::FromGlibPtrNone<*mut ffi::GstIterator> for
impl<T: StaticType> glib::translate::FromGlibPtrBorrow<*mut ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstIterator) -> Self {
assert!(!ptr.is_null());
assert_ne!(
gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().to_glib()),
glib_ffi::GFALSE
);
Self {
iter: ptr,
iter: ptr::NonNull::new_unchecked(ptr),
borrowed: true,
phantom: PhantomData,
}
@ -609,12 +610,13 @@ impl<T: StaticType> glib::translate::FromGlibPtrBorrow<*mut ffi::GstIterator> fo
impl<T: StaticType> glib::translate::FromGlibPtrFull<*mut ffi::GstIterator> for Iterator<T> {
#[inline]
unsafe fn from_glib_full(ptr: *mut ffi::GstIterator) -> Self {
assert!(!ptr.is_null());
assert_ne!(
gobject_ffi::g_type_is_a((*ptr).type_, T::static_type().to_glib()),
glib_ffi::GFALSE
);
Self {
iter: ptr,
iter: ptr::NonNull::new_unchecked(ptr),
borrowed: false,
phantom: PhantomData,
}

26
gstreamer/src/log.rs
View file

@ -19,7 +19,7 @@ use glib::IsA;
use glib::translate::{from_glib, ToGlib, ToGlibPtr};
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct DebugCategory(*mut ffi::GstDebugCategory);
pub struct DebugCategory(ptr::NonNull<ffi::GstDebugCategory>);
impl DebugCategory {
pub fn new<'a, P: Into<Option<&'a str>>>(
@ -38,11 +38,13 @@ impl DebugCategory {
// Gets the category if it exists already
unsafe {
DebugCategory(_gst_debug_category_new(
let ptr = _gst_debug_category_new(
name.to_glib_none().0,
color.to_glib(),
description.to_glib_none().0,
))
);
assert!(!ptr.is_null());
DebugCategory(ptr::NonNull::new_unchecked(ptr))
}
}
@ -57,34 +59,34 @@ impl DebugCategory {
if cat.is_null() {
None
} else {
Some(DebugCategory(cat))
Some(DebugCategory(ptr::NonNull::new_unchecked(cat)))
}
}
}
pub fn get_threshold(&self) -> ::DebugLevel {
from_glib(unsafe { ffi::gst_debug_category_get_threshold(self.0) })
from_glib(unsafe { ffi::gst_debug_category_get_threshold(self.0.as_ptr()) })
}
pub fn set_threshold(&self, threshold: ::DebugLevel) {
unsafe { ffi::gst_debug_category_set_threshold(self.0, threshold.to_glib()) }
unsafe { ffi::gst_debug_category_set_threshold(self.0.as_ptr(), threshold.to_glib()) }
}
pub fn reset_threshold(&self) {
unsafe { ffi::gst_debug_category_reset_threshold(self.0) }
unsafe { ffi::gst_debug_category_reset_threshold(self.0.as_ptr()) }
}
pub fn get_color(&self) -> ::DebugColorFlags {
unsafe {
from_glib(mem::transmute::<u32, ffi::GstDebugColorFlags>(
ffi::gst_debug_category_get_color(self.0),
ffi::gst_debug_category_get_color(self.0.as_ptr()),
))
}
}
pub fn get_name(&self) -> &str {
unsafe {
CStr::from_ptr(ffi::gst_debug_category_get_name(self.0))
CStr::from_ptr(ffi::gst_debug_category_get_name(self.0.as_ptr()))
.to_str()
.unwrap()
}
@ -92,7 +94,7 @@ impl DebugCategory {
pub fn get_description(&self) -> Option<&str> {
unsafe {
let ptr = ffi::gst_debug_category_get_name(self.0);
let ptr = ffi::gst_debug_category_get_name(self.0.as_ptr());
if ptr.is_null() {
None
@ -113,7 +115,7 @@ impl DebugCategory {
args: fmt::Arguments,
) {
unsafe {
if level.to_glib() as i32 > (*self.0).threshold {
if level.to_glib() as i32 > self.0.as_ref().threshold {
return;
}
}
@ -125,7 +127,7 @@ impl DebugCategory {
unsafe {
ffi::gst_debug_log(
self.0,
self.0.as_ptr(),
level.to_glib(),
file.to_glib_none().0,
module.to_glib_none().0,

19
gstreamer/src/miniobject.rs
View file

@ -22,7 +22,7 @@ use glib::translate::{c_ptr_array_len, from_glib, from_glib_full, from_glib_none
use glib;
pub struct GstRc<T: MiniObject> {
obj: *mut T,
obj: ptr::NonNull<T>,
borrowed: bool,
phantom: PhantomData<T>,
}
@ -34,7 +34,7 @@ impl<T: MiniObject> GstRc<T> {
ffi::gst_mini_object_ref(ptr as *mut ffi::GstMiniObject);
GstRc {
obj: T::from_mut_ptr(ptr as *mut T::GstType) as *mut T,
obj: ptr::NonNull::new_unchecked(T::from_mut_ptr(ptr as *mut T::GstType) as *mut T),
borrowed: false,
phantom: PhantomData,
}
@ -44,7 +44,7 @@ impl<T: MiniObject> GstRc<T> {
assert!(!ptr.is_null());
GstRc {
obj: T::from_mut_ptr(ptr as *mut T::GstType) as *mut T,
obj: ptr::NonNull::new_unchecked(T::from_mut_ptr(ptr as *mut T::GstType) as *mut T),
borrowed: false,
phantom: PhantomData,
}
@ -54,7 +54,7 @@ impl<T: MiniObject> GstRc<T> {
assert!(!ptr.is_null());
GstRc {
obj: T::from_mut_ptr(ptr as *mut T::GstType) as *mut T,
obj: ptr::NonNull::new_unchecked(T::from_mut_ptr(ptr as *mut T::GstType) as *mut T),
borrowed: true,
phantom: PhantomData,
}
@ -63,22 +63,23 @@ impl<T: MiniObject> GstRc<T> {
pub fn make_mut(&mut self) -> &mut T {
unsafe {
if self.is_writable() {
return &mut *self.obj;
return self.obj.as_mut();
}
self.obj = T::from_mut_ptr(
let ptr = T::from_mut_ptr(
ffi::gst_mini_object_make_writable(self.as_mut_ptr() as *mut ffi::GstMiniObject)
as *mut T::GstType,
);
self.obj = ptr::NonNull::new_unchecked(ptr);
assert!(self.is_writable());
&mut *self.obj
self.obj.as_mut()
}
}
pub fn get_mut(&mut self) -> Option<&mut T> {
if self.is_writable() {
Some(unsafe { &mut *self.obj })
Some(unsafe { self.obj.as_mut() })
} else {
None
}
@ -107,7 +108,7 @@ impl<T: MiniObject> ops::Deref for GstRc<T> {
impl<T: MiniObject> AsRef<T> for GstRc<T> {
fn as_ref(&self) -> &T {
unsafe { &*self.obj }
unsafe { self.obj.as_ref() }
}
}

17
gstreamer/src/static_caps.rs
View file

@ -15,12 +15,14 @@ use gobject_ffi;
use glib;
use glib::translate::{from_glib_full, FromGlibPtrNone, ToGlibPtr, ToGlibPtrMut};
use std::ptr;
#[repr(C)]
pub struct StaticCaps(*mut ffi::GstStaticCaps);
pub struct StaticCaps(ptr::NonNull<ffi::GstStaticCaps>);
impl StaticCaps {
pub fn get(&self) -> Caps {
unsafe { from_glib_full(ffi::gst_static_caps_get(self.0)) }
unsafe { from_glib_full(ffi::gst_static_caps_get(self.0.as_ptr())) }
}
}
@ -72,7 +74,7 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticCaps> for StaticCap
type Storage = &'a StaticCaps;
fn to_glib_none(&'a self) -> glib::translate::Stash<'a, *const ffi::GstStaticCaps, Self> {
glib::translate::Stash(self.0, self)
glib::translate::Stash(self.0.as_ptr(), self)
}
fn to_glib_full(&self) -> *const ffi::GstStaticCaps {
@ -84,7 +86,8 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticCaps> for StaticCap
impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstStaticCaps) -> Self {
StaticCaps(ptr as *mut _)
assert!(!ptr.is_null());
StaticCaps(ptr::NonNull::new_unchecked(ptr as *mut _))
}
}
@ -92,7 +95,8 @@ impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticCaps> for StaticCaps
impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstStaticCaps) -> Self {
StaticCaps(ptr)
assert!(!ptr.is_null());
StaticCaps(ptr::NonNull::new_unchecked(ptr))
}
}
@ -100,7 +104,8 @@ impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticCaps> for StaticCaps {
impl glib::translate::FromGlibPtrBorrow<*mut ffi::GstStaticCaps> for StaticCaps {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstStaticCaps) -> Self {
StaticCaps(ptr)
assert!(!ptr.is_null());
StaticCaps(ptr::NonNull::new_unchecked(ptr))
}
}

29
gstreamer/src/static_pad_template.rs
View file

@ -17,28 +17,34 @@ use std::ffi::CStr;
use glib;
use glib::translate::{from_glib, from_glib_full, FromGlibPtrNone, ToGlibPtr, ToGlibPtrMut};
use std::ptr;
#[repr(C)]
pub struct StaticPadTemplate(*mut ffi::GstStaticPadTemplate);
pub struct StaticPadTemplate(ptr::NonNull<ffi::GstStaticPadTemplate>);
impl StaticPadTemplate {
pub fn get(&self) -> PadTemplate {
unsafe { from_glib_full(ffi::gst_static_pad_template_get(self.0)) }
unsafe { from_glib_full(ffi::gst_static_pad_template_get(self.0.as_ptr())) }
}
pub fn get_caps(&self) -> Caps {
unsafe { from_glib_full(ffi::gst_static_pad_template_get_caps(self.0)) }
unsafe { from_glib_full(ffi::gst_static_pad_template_get_caps(self.0.as_ptr())) }
}
pub fn name_template<'a>(&self) -> &'a str {
unsafe { CStr::from_ptr((*self.0).name_template).to_str().unwrap() }
unsafe {
CStr::from_ptr(self.0.as_ref().name_template)
.to_str()
.unwrap()
}
}
pub fn direction(&self) -> ::PadDirection {
unsafe { from_glib((*self.0).direction) }
unsafe { from_glib(self.0.as_ref().direction) }
}
pub fn presence(&self) -> ::PadPresence {
unsafe { from_glib((*self.0).presence) }
unsafe { from_glib(self.0.as_ref().presence) }
}
}
@ -94,7 +100,7 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticPadTemplate> for St
fn to_glib_none(
&'a self,
) -> glib::translate::Stash<'a, *const ffi::GstStaticPadTemplate, Self> {
glib::translate::Stash(self.0, self)
glib::translate::Stash(self.0.as_ptr(), self)
}
fn to_glib_full(&self) -> *const ffi::GstStaticPadTemplate {
@ -106,7 +112,8 @@ impl<'a> glib::translate::ToGlibPtr<'a, *const ffi::GstStaticPadTemplate> for St
impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_none(ptr: *const ffi::GstStaticPadTemplate) -> Self {
StaticPadTemplate(ptr as *mut _)
assert!(!ptr.is_null());
StaticPadTemplate(ptr::NonNull::new_unchecked(ptr as *mut _))
}
}
@ -114,7 +121,8 @@ impl glib::translate::FromGlibPtrNone<*const ffi::GstStaticPadTemplate> for Stat
impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_none(ptr: *mut ffi::GstStaticPadTemplate) -> Self {
StaticPadTemplate(ptr)
assert!(!ptr.is_null());
StaticPadTemplate(ptr::NonNull::new_unchecked(ptr))
}
}
@ -122,7 +130,8 @@ impl glib::translate::FromGlibPtrNone<*mut ffi::GstStaticPadTemplate> for Static
impl glib::translate::FromGlibPtrBorrow<*mut ffi::GstStaticPadTemplate> for StaticPadTemplate {
#[inline]
unsafe fn from_glib_borrow(ptr: *mut ffi::GstStaticPadTemplate) -> Self {
StaticPadTemplate(ptr)
assert!(!ptr.is_null());
StaticPadTemplate(ptr::NonNull::new_unchecked(ptr))
}
}

81
gstreamer/src/structure.rs
View file

@ -25,7 +25,7 @@ use ffi;
use glib_ffi::gpointer;
use gobject_ffi;
pub struct Structure(*mut StructureRef, PhantomData<StructureRef>);
pub struct Structure(ptr::NonNull<StructureRef>, PhantomData<StructureRef>);
unsafe impl Send for Structure {}
impl Structure {
@ -36,10 +36,11 @@ impl Structure {
pub fn new_empty(name: &str) -> Structure {
assert_initialized_main_thread!();
Structure(
unsafe { ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef },
PhantomData,
)
unsafe {
let ptr = ffi::gst_structure_new_empty(name.to_glib_none().0) as *mut StructureRef;
assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr), PhantomData)
}
}
pub fn new(name: &str, values: &[(&str, &ToSendValue)]) -> Structure {
@ -60,13 +61,16 @@ impl Structure {
if structure.is_null() {
None
} else {
Some(Structure(structure as *mut StructureRef, PhantomData))
Some(Structure(
ptr::NonNull::new_unchecked(structure as *mut StructureRef),
PhantomData,
))
}
}
}
pub unsafe fn into_ptr(self) -> *mut ffi::GstStructure {
let ptr = self.0 as *mut StructureRef as *mut ffi::GstStructure;
let ptr = self.0.as_ptr() as *mut StructureRef as *mut ffi::GstStructure;
mem::forget(self);
ptr
@ -77,13 +81,13 @@ impl Deref for Structure {
type Target = StructureRef;
fn deref(&self) -> &StructureRef {
unsafe { &*self.0 }
unsafe { self.0.as_ref() }
}
}
impl DerefMut for Structure {
fn deref_mut(&mut self) -> &mut StructureRef {
unsafe { &mut *self.0 }
unsafe { self.0.as_mut() }
}
}
@ -101,16 +105,17 @@ impl AsMut<StructureRef> for Structure {
impl Clone for Structure {
fn clone(&self) -> Self {
Structure(
unsafe { ffi::gst_structure_copy(&(*self.0).0) as *mut StructureRef },
PhantomData,
)
unsafe {
let ptr = ffi::gst_structure_copy(&self.0.as_ref().0) as *mut StructureRef;
assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr), PhantomData)
}
}
}
impl Drop for Structure {
fn drop(&mut self) {
unsafe { ffi::gst_structure_free(&mut (*self.0).0) }
unsafe { ffi::gst_structure_free(&mut self.0.as_mut().0) }
}
}
@ -151,13 +156,13 @@ impl str::FromStr for Structure {
impl Borrow<StructureRef> for Structure {
fn borrow(&self) -> &StructureRef {
unsafe { &*self.0 }
unsafe { self.0.as_ref() }
}
}
impl BorrowMut<StructureRef> for Structure {
fn borrow_mut(&mut self) -> &mut StructureRef {
unsafe { &mut *self.0 }
unsafe { self.0.as_mut() }
}
}
@ -165,10 +170,11 @@ impl ToOwned for StructureRef {
type Owned = Structure;
fn to_owned(&self) -> Structure {
Structure(
unsafe { ffi::gst_structure_copy(&self.0) as *mut StructureRef },
PhantomData,
)
unsafe {
let ptr = ffi::gst_structure_copy(&self.0) as *mut StructureRef;
assert!(!ptr.is_null());
Structure(ptr::NonNull::new_unchecked(ptr), PhantomData)
}
}
}
@ -182,11 +188,11 @@ impl<'a> ToGlibPtr<'a, *const ffi::GstStructure> for Structure {
type Storage = &'a Self;
fn to_glib_none(&'a self) -> Stash<'a, *const ffi::GstStructure, Self> {
Stash(unsafe { &(*self.0).0 }, self)
unsafe { Stash(&self.0.as_ref().0, self) }
}
fn to_glib_full(&self) -> *const ffi::GstStructure {
unsafe { ffi::gst_structure_copy(&(*self.0).0) }
unsafe { ffi::gst_structure_copy(&self.0.as_ref().0) }
}
}
@ -194,11 +200,11 @@ impl<'a> ToGlibPtr<'a, *mut ffi::GstStructure> for Structure {
type Storage = &'a Self;
fn to_glib_none(&'a self) -> Stash<'a, *mut ffi::GstStructure, Self> {
Stash(unsafe { &mut (*self.0).0 }, self)
unsafe { Stash(&self.0.as_ref().0 as *const _ as *mut _, self) }
}
fn to_glib_full(&self) -> *mut ffi::GstStructure {
unsafe { ffi::gst_structure_copy(&(*self.0).0) }
unsafe { ffi::gst_structure_copy(&self.0.as_ref().0) }
}
}
@ -206,14 +212,17 @@ impl<'a> ToGlibPtrMut<'a, *mut ffi::GstStructure> for Structure {
type Storage = &'a mut Self;
fn to_glib_none_mut(&'a mut self) -> StashMut<*mut ffi::GstStructure, Self> {
StashMut(unsafe { &mut (*self.0).0 }, self)
unsafe { StashMut(&mut self.0.as_mut().0, self) }
}
}
impl FromGlibPtrNone<*const ffi::GstStructure> for Structure {
unsafe fn from_glib_none(ptr: *const ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
let ptr = ffi::gst_structure_copy(ptr);
assert!(!ptr.is_null());
Structure(
ffi::gst_structure_copy(ptr) as *mut StructureRef,
ptr::NonNull::new_unchecked(ptr as *mut StructureRef),
PhantomData,
)
}
@ -221,8 +230,11 @@ impl FromGlibPtrNone<*const ffi::GstStructure> for Structure {
impl FromGlibPtrNone<*mut ffi::GstStructure> for Structure {
unsafe fn from_glib_none(ptr: *mut ffi::GstStructure) -> Self {
assert!(!ptr.is_null());
let ptr = ffi::gst_structure_copy(ptr);
assert!(!ptr.is_null());
Structure(
ffi::gst_structure_copy(ptr) as *mut StructureRef,
ptr::NonNull::new_unchecked(ptr as *mut StructureRef),
PhantomData,
)
}
@ -230,26 +242,35 @@ impl FromGlibPtrNone<*mut ffi::GstStructure> for Structure {
impl FromGlibPtrFull<*const ffi::GstStructure> for Structure {
unsafe fn from_glib_full(ptr: *const ffi::GstStructure) -> Self {
Structure(ptr as *mut StructureRef, PhantomData)
assert!(!ptr.is_null());
Structure(
ptr::NonNull::new_unchecked(ptr as *mut StructureRef),
PhantomData,
)
}
}
impl FromGlibPtrFull<*mut ffi::GstStructure> for Structure {
unsafe fn from_glib_full(ptr: *mut ffi::GstStructure) -> Self {
Structure(ptr as *mut StructureRef, PhantomData)
assert!(!ptr.is_null());
Structure(
ptr::NonNull::new_unchecked(ptr as *mut StructureRef),
PhantomData,
)
}
}
impl<'a> glib::value::FromValueOptional<'a> for Structure {
unsafe fn from_value_optional(v: &'a glib::Value) -> Option<Self> {
let ptr = gobject_ffi::g_value_get_boxed(v.to_glib_none().0);
assert!(!ptr.is_null());
from_glib_none(ptr as *const ffi::GstStructure)
}
}
impl glib::value::SetValue for Structure {
unsafe fn set_value(v: &mut glib::Value, s: &Self) {
gobject_ffi::g_value_set_boxed(v.to_glib_none_mut().0, s.0 as gpointer);
gobject_ffi::g_value_set_boxed(v.to_glib_none_mut().0, s.0.as_ptr() as gpointer);
}
}