hinawa: fix type of implementator argument in trait methods subclass

"Self::Type" is available for the type in traits for subclass provided
by  glib v0.15.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>

5 files changed, 34 insertions, 32 deletions

diff --git a/hinawa/src/subclass.rs b/hinawa/src/subclass.rs
index 514ecb6..778a46d 100644
--- a/hinawa/src/subclass.rs
+++ b/hinawa/src/subclass.rs
@@ -6,17 +6,12 @@ mod fw_req;
 mod fw_resp;
 
 pub mod prelude {
-    pub use {
-        super::fw_fcp::{FwFcpImpl, FwFcpImplExt},
-        super::fw_node::{FwNodeImpl, FwNodeImplExt},
-        super::fw_req::{FwReqImpl, FwReqImplExt},
-        super::fw_resp::{FwRespImpl, FwRespImplExt},
-    };
+    pub use {super::fw_fcp::*, super::fw_node::*, super::fw_req::*, super::fw_resp::*};
 }
 
 use {
-    self::prelude::*,
     super::*,
     glib::{subclass::prelude::*, translate::*, Class},
     libc::*,
+    prelude::*,
 };
diff --git a/hinawa/src/subclass/fw_fcp.rs b/hinawa/src/subclass/fw_fcp.rs
index e1a0dd0..4c0ca27 100644
--- a/hinawa/src/subclass/fw_fcp.rs
+++ b/hinawa/src/subclass/fw_fcp.rs
@@ -3,24 +3,28 @@
 use super::*;
 
 pub trait FwFcpImpl: ObjectImpl + FwRespImpl + FwFcpImplExt {
-    fn responded(&self, fcp: &FwFcp, frame: &[u8]) {
+    fn responded(&self, fcp: &Self::Type, frame: &[u8]) {
         self.parent_responded(fcp, frame)
     }
 }
 
 pub trait FwFcpImplExt: ObjectSubclass {
-    fn parent_responded(&self, fcp: &FwFcp, frame: &[u8]);
+    fn parent_responded(&self, fcp: &Self::Type, frame: &[u8]);
 }
 
 impl<T: FwFcpImpl> FwFcpImplExt for T {
-    fn parent_responded(&self, fcp: &FwFcp, frame: &[u8]) {
+    fn parent_responded(&self, fcp: &Self::Type, frame: &[u8]) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::HinawaFwFcpClass;
             let f = (*parent_class)
                 .responded
                 .expect("No parent class implementation for \"responded\"");
-            f(fcp.to_glib_none().0, frame.as_ptr(), frame.len() as u32)
+            f(
+                fcp.unsafe_cast_ref::<FwFcp>().to_glib_none().0,
+                frame.as_ptr(),
+                frame.len() as u32,
+            )
         }
     }
 }
@@ -43,5 +47,8 @@ unsafe extern "C" fn fw_fcp_responded<T: FwFcpImpl>(
     let imp = instance.imp();
     let wrap: Borrowed<FwFcp> = from_glib_borrow(ptr);
 
-    imp.responded(&wrap, std::slice::from_raw_parts(frame, length as usize))
+    imp.responded(
+        wrap.unsafe_cast_ref(),
+        std::slice::from_raw_parts(frame, length as usize),
+    )
 }
diff --git a/hinawa/src/subclass/fw_node.rs b/hinawa/src/subclass/fw_node.rs
index 0503049..f6bc6e7 100644
--- a/hinawa/src/subclass/fw_node.rs
+++ b/hinawa/src/subclass/fw_node.rs
@@ -3,40 +3,40 @@
 use super::*;
 
 pub trait FwNodeImpl: ObjectImpl + FwNodeImplExt {
-    fn bus_update(&self, node: &FwNode) {
+    fn bus_update(&self, node: &Self::Type) {
         self.parent_bus_update(node)
     }
 
-    fn disconnected(&self, node: &FwNode) {
+    fn disconnected(&self, node: &Self::Type) {
         self.parent_disconnected(node)
     }
 }
 
 pub trait FwNodeImplExt: ObjectSubclass {
-    fn parent_bus_update(&self, node: &FwNode);
-    fn parent_disconnected(&self, node: &FwNode);
+    fn parent_bus_update(&self, node: &Self::Type);
+    fn parent_disconnected(&self, node: &Self::Type);
 }
 
 impl<T: FwNodeImpl> FwNodeImplExt for T {
-    fn parent_bus_update(&self, node: &FwNode) {
+    fn parent_bus_update(&self, node: &Self::Type) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::HinawaFwNodeClass;
             let f = (*parent_class)
                 .bus_update
                 .expect("No parent class implementation for \"bus_update\"");
-            f(node.to_glib_none().0)
+            f(node.unsafe_cast_ref::<FwNode>().to_glib_none().0)
         }
     }
 
-    fn parent_disconnected(&self, node: &FwNode) {
+    fn parent_disconnected(&self, node: &Self::Type) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::HinawaFwNodeClass;
             let f = (*parent_class)
                 .disconnected
                 .expect("No parent class implementation for \"disconnected\"");
-            f(node.to_glib_none().0);
+            f(node.unsafe_cast_ref::<FwNode>().to_glib_none().0)
         }
     }
 }
@@ -56,7 +56,7 @@ unsafe extern "C" fn fw_node_bus_update<T: FwNodeImpl>(ptr: *mut ffi::HinawaFwNo
     let imp = instance.imp();
     let wrap: Borrowed<FwNode> = from_glib_borrow(ptr);
 
-    imp.bus_update(&wrap)
+    imp.bus_update(wrap.unsafe_cast_ref())
 }
 
 unsafe extern "C" fn fw_node_disconnected<T: FwNodeImpl>(ptr: *mut ffi::HinawaFwNode) {
@@ -64,5 +64,5 @@ unsafe extern "C" fn fw_node_disconnected<T: FwNodeImpl>(ptr: *mut ffi::HinawaFw
     let imp = instance.imp();
     let wrap: Borrowed<FwNode> = from_glib_borrow(ptr);
 
-    imp.disconnected(&wrap)
+    imp.disconnected(wrap.unsafe_cast_ref())
 }
diff --git a/hinawa/src/subclass/fw_req.rs b/hinawa/src/subclass/fw_req.rs
index d174715..9b4366f 100644
--- a/hinawa/src/subclass/fw_req.rs
+++ b/hinawa/src/subclass/fw_req.rs
@@ -3,17 +3,17 @@
 use super::*;
 
 pub trait FwReqImpl: ObjectImpl + FwReqImplExt {
-    fn responded(&self, req: &FwReq, rcode: FwRcode, frame: &[u8]) {
+    fn responded(&self, req: &Self::Type, rcode: FwRcode, frame: &[u8]) {
         self.parent_responded(req, rcode, frame)
     }
 }
 
 pub trait FwReqImplExt: ObjectSubclass {
-    fn parent_responded(&self, req: &FwReq, rcode: FwRcode, frame: &[u8]);
+    fn parent_responded(&self, req: &Self::Type, rcode: FwRcode, frame: &[u8]);
 }
 
 impl<T: FwReqImpl> FwReqImplExt for T {
-    fn parent_responded(&self, req: &FwReq, rcode: FwRcode, frame: &[u8]) {
+    fn parent_responded(&self, req: &Self::Type, rcode: FwRcode, frame: &[u8]) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::HinawaFwReqClass;
@@ -21,7 +21,7 @@ impl<T: FwReqImpl> FwReqImplExt for T {
                 .responded
                 .expect("No parent class implementation for \"responded\"");
             f(
-                req.to_glib_none().0,
+                req.unsafe_cast_ref::<FwReq>().to_glib_none().0,
                 rcode.into_glib(),
                 frame.as_ptr(),
                 frame.len() as u32,
@@ -50,7 +50,7 @@ unsafe extern "C" fn fw_req_responded<T: FwReqImpl>(
     let wrap: Borrowed<FwReq> = from_glib_borrow(ptr);
 
     imp.responded(
-        &wrap,
+        wrap.unsafe_cast_ref(),
         from_glib(rcode),
         std::slice::from_raw_parts(frame, length as usize),
     )
diff --git a/hinawa/src/subclass/fw_resp.rs b/hinawa/src/subclass/fw_resp.rs
index 94fc40c..cfd2989 100644
--- a/hinawa/src/subclass/fw_resp.rs
+++ b/hinawa/src/subclass/fw_resp.rs
@@ -5,7 +5,7 @@ use super::*;
 pub trait FwRespImpl: ObjectImpl + FwRespImplExt {
     fn requested2(
         &self,
-        resp: &FwResp,
+        resp: &Self::Type,
         tcode: FwTcode,
         offset: u64,
         src: u32,
@@ -21,7 +21,7 @@ pub trait FwRespImpl: ObjectImpl + FwRespImplExt {
 pub trait FwRespImplExt: ObjectSubclass {
     fn parent_requested2(
         &self,
-        resp: &FwResp,
+        resp: &Self::Type,
         tcode: FwTcode,
         offset: u64,
         src: u32,
@@ -35,7 +35,7 @@ pub trait FwRespImplExt: ObjectSubclass {
 impl<T: FwRespImpl> FwRespImplExt for T {
     fn parent_requested2(
         &self,
-        resp: &FwResp,
+        resp: &Self::Type,
         tcode: FwTcode,
         offset: u64,
         src: u32,
@@ -51,7 +51,7 @@ impl<T: FwRespImpl> FwRespImplExt for T {
                 .requested2
                 .expect("No parent class implementation for \"requested2\"");
             from_glib(f(
-                resp.to_glib_none().0,
+                resp.unsafe_cast_ref::<FwResp>().to_glib_none().0,
                 tcode.into_glib(),
                 offset,
                 src,
@@ -90,7 +90,7 @@ unsafe extern "C" fn fw_resp_requested2<T: FwRespImpl>(
     let wrap: Borrowed<FwResp> = from_glib_borrow(ptr);
 
     imp.requested2(
-        &wrap,
+        wrap.unsafe_cast_ref(),
         from_glib(tcode),
         offset,
         src,