Remove subclass::Boxed wrapper type

This is redundant with the GBoxed derive macro.

Author: sdroege

glib/src/subclass/boxed.rs

@@ -3,8 +3,6 @@
 //! Module for registering boxed types for Rust types.
 
 use crate::translate::*;
-use crate::value::*;
-use std::ops;
 
 /// Trait for defining boxed types.
 ///
@@ -66,71 +64,12 @@ pub fn register_boxed_type<T: BoxedType>() -> crate::Type {
     }
 }
 
-/// Wrapper struct for storing any `BoxedType` in `glib::Value`.
-///
-/// Instead of this the [`GBoxed!`] derive macro can be used to
-/// directly implement the relevant traits on the type itself.
-///
-/// [`GBoxed!`]: ../../derive.GBoxed.html
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Boxed<T: BoxedType>(pub T);
-
-impl<T: BoxedType> ops::Deref for Boxed<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.0
-    }
-}
-
-impl<T: BoxedType> ops::DerefMut for Boxed<T> {
-    fn deref_mut(&mut self) -> &mut T {
-        &mut self.0
-    }
-}
-
-impl<T: BoxedType> crate::StaticType for Boxed<T> {
-    fn static_type() -> crate::Type {
-        T::get_type()
-    }
-}
-
-impl<T: BoxedType> SetValue for Boxed<T> {
-    unsafe fn set_value(value: &mut Value, this: &Self) {
-        let ptr: *mut Boxed<T> = Box::into_raw(Box::new(this.clone()));
-        gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, ptr as *mut _);
-    }
-}
-
-impl<T: BoxedType> SetValueOptional for Boxed<T> {
-    unsafe fn set_value_optional(value: &mut Value, this: Option<&Self>) {
-        let this = this.expect("None not allowed");
-        let ptr: *mut Boxed<T> = Box::into_raw(Box::new(this.clone()));
-        gobject_ffi::g_value_take_boxed(value.to_glib_none_mut().0, ptr as *mut _);
-    }
-}
-
-impl<'a, T: BoxedType> FromValueOptional<'a> for &'a Boxed<T> {
-    unsafe fn from_value_optional(value: &'a Value) -> Option<Self> {
-        let ptr = gobject_ffi::g_value_get_boxed(value.to_glib_none().0);
-        assert!(!ptr.is_null());
-        Some(&*(ptr as *mut Boxed<T>))
-    }
-}
-
-impl<'a, T: BoxedType> FromValue<'a> for &'a Boxed<T> {
-    unsafe fn from_value(value: &'a Value) -> Self {
-        let ptr = gobject_ffi::g_value_get_boxed(value.to_glib_none().0);
-        assert!(!ptr.is_null());
-        &*(ptr as *mut Boxed<T>)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
     // GBoxed macro assumes 'glib' is in scope
     use crate as glib;
+    use crate::value::ToValue;
 
     #[derive(Clone, Debug, PartialEq, Eq, glib::GBoxed)]
     #[gboxed(type_name = "MyBoxed")]
@@ -141,16 +80,6 @@ mod test {
         assert_ne!(crate::Type::Invalid, MyBoxed::get_type());
     }
 
-    #[test]
-    fn test_value_boxed() {
-        assert_ne!(crate::Type::Invalid, MyBoxed::get_type());
-
-        let b = Boxed(MyBoxed(String::from("abc")));
-        let v = b.to_value();
-        let b2 = v.get_some::<&Boxed<MyBoxed>>().unwrap();
-        assert_eq!(&b, b2);
-    }
-
     #[test]
     fn test_value() {
         assert_ne!(crate::Type::Invalid, MyBoxed::get_type());