Merge pull request #895 from pbor/boxed_mut

sdroege · web-flow · commit 776120e820ec · 2023-01-17T09:49:07.000+02:00
glib: implement ToGlibPtr&lt;*mut _&gt; for boxed types
diff --git a/glib/src/boxed.rs b/glib/src/boxed.rs
@@ -90,6 +90,22 @@ macro_rules! glib_boxed_wrapper {
             }
         }
 
+        #[doc(hidden)]
+        impl<'a $(, $($generic $(: $bound $(+ $bound2)*)?),+)?> $crate::translate::ToGlibPtr<'a, *mut $ffi_name> for $name $(<$($generic),+>)? {
+            type Storage = std::marker::PhantomData<&'a $crate::boxed::Boxed<$ffi_name, Self>>;
+
+            #[inline]
+            fn to_glib_none(&'a self) -> $crate::translate::Stash<'a, *mut $ffi_name, Self> {
+                let stash = $crate::translate::ToGlibPtr::to_glib_none(&self.inner);
+                $crate::translate::Stash(stash.0 as *mut _, stash.1)
+            }
+
+            #[inline]
+            fn to_glib_full(&self) -> *mut $ffi_name {
+                $crate::translate::ToGlibPtr::to_glib_full(&self.inner) as *mut _
+            }
+        }
+
         #[doc(hidden)]
         impl<'a $(, $($generic $(: $bound $(+ $bound2)*)?),+)?> $crate::translate::ToGlibPtrMut<'a, *mut $ffi_name> for $name $(<$($generic),+>)? {
             type Storage = std::marker::PhantomData<&'a mut $crate::boxed::Boxed<$ffi_name, Self>>;
diff --git a/glib/src/collections/ptr_slice.rs b/glib/src/collections/ptr_slice.rs
@@ -1193,10 +1193,10 @@ mod test {
 
         let slice = unsafe {
             let ptr = ffi::g_malloc(mem::size_of::<ffi::GDate>() * 4) as *mut *mut ffi::GError;
-            ptr::write(ptr.add(0), items[0].to_glib_full() as *mut _);
-            ptr::write(ptr.add(1), items[1].to_glib_full() as *mut _);
-            ptr::write(ptr.add(2), items[2].to_glib_full() as *mut _);
-            ptr::write(ptr.add(3), items[3].to_glib_full() as *mut _);
+            ptr::write(ptr.add(0), items[0].to_glib_full());
+            ptr::write(ptr.add(1), items[1].to_glib_full());
+            ptr::write(ptr.add(2), items[2].to_glib_full());
+            ptr::write(ptr.add(3), items[3].to_glib_full());
 
             PtrSlice::<crate::Error>::from_glib_full_num(ptr, 4, false)
         };
diff --git a/glib/src/value_array.rs b/glib/src/value_array.rs
@@ -114,8 +114,8 @@ impl ops::Deref for ValueArray {
 
         unsafe {
             slice::from_raw_parts(
-                (*self.to_glib_none().0).values as *const Value,
-                (*self.to_glib_none().0).n_values as usize,
+                (*self.as_ptr()).values as *const Value,
+                (*self.as_ptr()).n_values as usize,
             )
         }
     }
@@ -130,8 +130,8 @@ impl ops::DerefMut for ValueArray {
 
         unsafe {
             slice::from_raw_parts_mut(
-                (*self.to_glib_none().0).values as *mut Value,
-                (*self.to_glib_none().0).n_values as usize,
+                (*self.as_ptr()).values as *mut Value,
+                (*self.as_ptr()).n_values as usize,
             )
         }
     }
diff --git a/pango/src/attr_list.rs b/pango/src/attr_list.rs
@@ -11,7 +11,7 @@ impl AttrList {
     pub fn change(&self, attr: impl Into<Attribute>) {
         unsafe {
             let attr = attr.into();
-            ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0 as *mut _);
+            ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0);
             mem::forget(attr); //As attr transferred fully
         }
     }
@@ -32,7 +32,7 @@ impl AttrList {
     pub fn insert(&self, attr: impl Into<Attribute>) {
         unsafe {
             let attr = attr.into();
-            ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0 as *mut _);
+            ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0);
             mem::forget(attr); //As attr transferred fully
         }
     }
@@ -41,10 +41,7 @@ impl AttrList {
     pub fn insert_before(&self, attr: impl Into<Attribute>) {
         unsafe {
             let attr = attr.into();
-            ffi::pango_attr_list_insert_before(
-                self.to_glib_none().0,
-                attr.to_glib_none().0 as *mut _,
-            );
+            ffi::pango_attr_list_insert_before(self.to_glib_none().0, attr.to_glib_none().0);
             mem::forget(attr); //As attr transferred fully
         }
     }
diff --git a/pango/src/attribute.rs b/pango/src/attribute.rs
@@ -8,45 +8,37 @@ impl Attribute {
     #[doc(alias = "get_attr_class")]
     #[inline]
     pub fn attr_class(&self) -> AttrClass {
-        unsafe { from_glib_none((*self.to_glib_none().0).klass) }
+        unsafe { from_glib_none((*self.as_ptr()).klass) }
     }
 
     #[inline]
     pub fn type_(&self) -> AttrType {
-        unsafe { from_glib((*(*self.to_glib_none().0).klass).type_) }
+        unsafe { from_glib((*(*self.as_ptr()).klass).type_) }
     }
 
     #[doc(alias = "get_start_index")]
     #[inline]
     pub fn start_index(&self) -> u32 {
-        unsafe {
-            let stash = self.to_glib_none();
-            (*stash.0).start_index
-        }
+        unsafe { (*self.as_ptr()).start_index }
     }
 
     #[doc(alias = "get_end_index")]
     #[inline]
     pub fn end_index(&self) -> u32 {
-        unsafe {
-            let stash = self.to_glib_none();
-            (*stash.0).end_index
-        }
+        unsafe { (*self.as_ptr()).end_index }
     }
 
     #[inline]
     pub fn set_start_index(&mut self, index: u32) {
         unsafe {
-            let stash = self.to_glib_none_mut();
-            (*stash.0).start_index = index;
+            (*self.as_ptr()).start_index = index;
         }
     }
 
     #[inline]
     pub fn set_end_index(&mut self, index: u32) {
         unsafe {
-            let stash = self.to_glib_none_mut();
-            (*stash.0).end_index = index;
+            (*self.as_ptr()).end_index = index;
         }
     }
 
@@ -120,9 +112,8 @@ macro_rules! define_attribute_struct {
             #[doc(alias = "pango_attribute_equal")]
             fn equal<'a, T:  crate::attribute::IsAttribute>(&self, attr2: &'a T) -> bool {
                 unsafe {
-                    glib::translate::from_glib(ffi::pango_attribute_equal(
-                       glib::translate::ToGlibPtr::to_glib_none(self).0 as *const ffi::PangoAttribute,
-                       glib::translate::ToGlibPtr::to_glib_none(attr2.upcast_ref()).0 as *const ffi::PangoAttribute,
+                    glib::translate::from_glib(ffi::pango_attribute_equal(self.as_ptr() as *const ffi::PangoAttribute,
+                       glib::translate::ToGlibPtr::to_glib_none(attr2.upcast_ref()).0,
                     ))
                 }
             }
diff --git a/pango/src/glyph_item.rs b/pango/src/glyph_item.rs
@@ -6,11 +6,11 @@ use crate::{GlyphItem, GlyphString, Item};
 
 impl GlyphItem {
     pub fn item(&self) -> Item {
-        unsafe { from_glib_none((*self.to_glib_none().0).item) }
+        unsafe { from_glib_none((*self.as_ptr()).item) }
     }
 
     pub fn glyph_string(&self) -> GlyphString {
-        unsafe { from_glib_none((*self.to_glib_none().0).glyphs) }
+        unsafe { from_glib_none((*self.as_ptr()).glyphs) }
     }
 
     #[doc(alias = "pango_glyph_item_get_logical_widths")]
diff --git a/pango/src/glyph_string.rs b/pango/src/glyph_string.rs
@@ -7,37 +7,37 @@ use crate::{GlyphInfo, GlyphString};
 impl GlyphString {
     #[inline]
     pub fn num_glyphs(&self) -> i32 {
-        unsafe { (*self.to_glib_none().0).num_glyphs }
+        unsafe { (*self.as_ptr()).num_glyphs }
     }
 
     #[inline]
     pub fn glyph_info(&self) -> &[GlyphInfo] {
         unsafe {
-            let ptr = (*self.to_glib_none().0).glyphs;
+            let ptr = (*self.as_ptr()).glyphs;
             Slice::from_glib_borrow_num(ptr, self.num_glyphs() as usize)
         }
     }
 
     #[inline]
     pub fn glyph_info_mut(&mut self) -> &mut [GlyphInfo] {
         unsafe {
-            let ptr = (*self.to_glib_none().0).glyphs;
+            let ptr = (*self.as_ptr()).glyphs;
             Slice::from_glib_borrow_num_mut(ptr, self.num_glyphs() as usize)
         }
     }
 
     #[inline]
     pub fn log_clusters(&self) -> &[i32] {
         unsafe {
-            let ptr = (*self.to_glib_none().0).log_clusters as *const i32;
+            let ptr = (*self.as_ptr()).log_clusters as *const i32;
             Slice::from_glib_borrow_num(ptr, self.num_glyphs() as usize)
         }
     }
 
     #[inline]
     pub fn log_clusters_mut(&mut self) -> &mut [i32] {
         unsafe {
-            let ptr = (*self.to_glib_none().0).log_clusters;
+            let ptr = (*self.as_ptr()).log_clusters;
             Slice::from_glib_borrow_num_mut(ptr, self.num_glyphs() as usize)
         }
     }
diff --git a/pango/src/item.rs b/pango/src/item.rs
@@ -1,23 +1,21 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::translate::*;
-
 use crate::{Analysis, Item};
 
 impl Item {
     pub fn offset(&self) -> i32 {
-        unsafe { (*self.to_glib_none().0).offset }
+        unsafe { (*self.as_ptr()).offset }
     }
 
     pub fn length(&self) -> i32 {
-        unsafe { (*self.to_glib_none().0).length }
+        unsafe { (*self.as_ptr()).length }
     }
 
     pub fn num_chars(&self) -> i32 {
-        unsafe { (*self.to_glib_none().0).num_chars }
+        unsafe { (*self.as_ptr()).num_chars }
     }
 
     pub fn analysis(&self) -> &Analysis {
-        unsafe { &*(&((*self.to_glib_none().0).analysis) as *const _ as *const Analysis) }
+        unsafe { &*(&((*self.as_ptr()).analysis) as *const _ as *const Analysis) }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -114,8 +114,8 @@ impl ops::Deref for ValueArray {`
`114`	`114`
`115`	`115`	`unsafe {`
`116`	`116`	`slice::from_raw_parts(`
`117`		`- (self.to_glib_none().0).values as const Value,`
`118`		`- (*self.to_glib_none().0).n_values as usize,`
	`117`	`+ (self.as_ptr()).values as const Value,`
	`118`	`+ (*self.as_ptr()).n_values as usize,`
`119`	`119`	`)`
`120`	`120`	`}`
`121`	`121`	`}`
`@@ -130,8 +130,8 @@ impl ops::DerefMut for ValueArray {`
`130`	`130`
`131`	`131`	`unsafe {`
`132`	`132`	`slice::from_raw_parts_mut(`
`133`		`- (self.to_glib_none().0).values as mut Value,`
`134`		`- (*self.to_glib_none().0).n_values as usize,`
	`133`	`+ (self.as_ptr()).values as mut Value,`
	`134`	`+ (*self.as_ptr()).n_values as usize,`
`135`	`135`	`)`
`136`	`136`	`}`
`137`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ impl AttrList {`
`11`	`11`	`pub fn change(&self, attr: impl Into<Attribute>) {`
`12`	`12`	`unsafe {`
`13`	`13`	`let attr = attr.into();`
`14`		`- ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0 as *mut _);`
	`14`	`+ ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0);`
`15`	`15`	`mem::forget(attr); //As attr transferred fully`
`16`	`16`	`}`
`17`	`17`	`}`
`@@ -32,7 +32,7 @@ impl AttrList {`
`32`	`32`	`pub fn insert(&self, attr: impl Into<Attribute>) {`
`33`	`33`	`unsafe {`
`34`	`34`	`let attr = attr.into();`
`35`		`- ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0 as *mut _);`
	`35`	`+ ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0);`
`36`	`36`	`mem::forget(attr); //As attr transferred fully`
`37`	`37`	`}`
`38`	`38`	`}`
`@@ -41,10 +41,7 @@ impl AttrList {`
`41`	`41`	`pub fn insert_before(&self, attr: impl Into<Attribute>) {`
`42`	`42`	`unsafe {`
`43`	`43`	`let attr = attr.into();`
`44`		`- ffi::pango_attr_list_insert_before(`
`45`		`- self.to_glib_none().0,`
`46`		`- attr.to_glib_none().0 as *mut _,`
`47`		`- );`
	`44`	`+ ffi::pango_attr_list_insert_before(self.to_glib_none().0, attr.to_glib_none().0);`
`48`	`45`	`mem::forget(attr); //As attr transferred fully`
`49`	`46`	`}`
`50`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ use crate::{GlyphItem, GlyphString, Item};`
`6`	`6`
`7`	`7`	`impl GlyphItem {`
`8`	`8`	`pub fn item(&self) -> Item {`
`9`		`- unsafe { from_glib_none((*self.to_glib_none().0).item) }`
	`9`	`+ unsafe { from_glib_none((*self.as_ptr()).item) }`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`pub fn glyph_string(&self) -> GlyphString {`
`13`		`- unsafe { from_glib_none((*self.to_glib_none().0).glyphs) }`
	`13`	`+ unsafe { from_glib_none((*self.as_ptr()).glyphs) }`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`#[doc(alias = "pango_glyph_item_get_logical_widths")]`
Original file line number	Diff line number	Diff line change
`@@ -7,37 +7,37 @@ use crate::{GlyphInfo, GlyphString};`
`7`	`7`	`impl GlyphString {`
`8`	`8`	`#[inline]`
`9`	`9`	`pub fn num_glyphs(&self) -> i32 {`
`10`		`- unsafe { (*self.to_glib_none().0).num_glyphs }`
	`10`	`+ unsafe { (*self.as_ptr()).num_glyphs }`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`#[inline]`
`14`	`14`	`pub fn glyph_info(&self) -> &[GlyphInfo] {`
`15`	`15`	`unsafe {`
`16`		`- let ptr = (*self.to_glib_none().0).glyphs;`
	`16`	`+ let ptr = (*self.as_ptr()).glyphs;`
`17`	`17`	`Slice::from_glib_borrow_num(ptr, self.num_glyphs() as usize)`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`#[inline]`
`22`	`22`	`pub fn glyph_info_mut(&mut self) -> &mut [GlyphInfo] {`
`23`	`23`	`unsafe {`
`24`		`- let ptr = (*self.to_glib_none().0).glyphs;`
	`24`	`+ let ptr = (*self.as_ptr()).glyphs;`
`25`	`25`	`Slice::from_glib_borrow_num_mut(ptr, self.num_glyphs() as usize)`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`#[inline]`
`30`	`30`	`pub fn log_clusters(&self) -> &[i32] {`
`31`	`31`	`unsafe {`
`32`		`- let ptr = (self.to_glib_none().0).log_clusters as const i32;`
	`32`	`+ let ptr = (self.as_ptr()).log_clusters as const i32;`
`33`	`33`	`Slice::from_glib_borrow_num(ptr, self.num_glyphs() as usize)`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`#[inline]`
`38`	`38`	`pub fn log_clusters_mut(&mut self) -> &mut [i32] {`
`39`	`39`	`unsafe {`
`40`		`- let ptr = (*self.to_glib_none().0).log_clusters;`
	`40`	`+ let ptr = (*self.as_ptr()).log_clusters;`
`41`	`41`	`Slice::from_glib_borrow_num_mut(ptr, self.num_glyphs() as usize)`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,23 +1,21 @@`
`1`	`1`	`// Take a look at the license at the top of the repository in the LICENSE file.`
`2`	`2`
`3`		`-use glib::translate::*;`
`4`		`-`
`5`	`3`	`use crate::{Analysis, Item};`
`6`	`4`
`7`	`5`	`impl Item {`
`8`	`6`	`pub fn offset(&self) -> i32 {`
`9`		`- unsafe { (*self.to_glib_none().0).offset }`
	`7`	`+ unsafe { (*self.as_ptr()).offset }`
`10`	`8`	`}`
`11`	`9`
`12`	`10`	`pub fn length(&self) -> i32 {`
`13`		`- unsafe { (*self.to_glib_none().0).length }`
	`11`	`+ unsafe { (*self.as_ptr()).length }`
`14`	`12`	`}`
`15`	`13`
`16`	`14`	`pub fn num_chars(&self) -> i32 {`
`17`		`- unsafe { (*self.to_glib_none().0).num_chars }`
	`15`	`+ unsafe { (*self.as_ptr()).num_chars }`
`18`	`16`	`}`
`19`	`17`
`20`	`18`	`pub fn analysis(&self) -> &Analysis {`
`21`		`- unsafe { &(&((self.to_glib_none().0).analysis) as const _ as const Analysis) }`
	`19`	`+ unsafe { &(&((self.as_ptr()).analysis) as const _ as const Analysis) }`
`22`	`20`	`}`
`23`	`21`	`}`