into_raw for Bindings

src/context.rs

@@ -502,6 +502,12 @@ unsafe impl<'a> Binding<'a> for Context {
     unsafe fn from_raw(_: &'a Self::Container, raw: *mut Self::CType) -> Self {
         Self { raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        std::mem::forget(self);
+        raw
+    }
 }
 
 // ===== helper functions =====

src/data.rs

@@ -725,6 +725,12 @@ unsafe impl<'a> Binding<'a> for DataTree<'a> {
     ) -> DataTree<'a> {
         DataTree { context, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        std::mem::forget(self);
+        raw
+    }
 }
 
 unsafe impl<'a> Send for DataTree<'a> {}
@@ -1099,6 +1105,16 @@ unsafe impl<'a, 'b> Binding<'a> for DataNodeRef<'a, 'b> {
     ) -> DataNodeRef<'a, 'b> {
         DataNodeRef { tree, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 impl<'a, 'b> NodeIterable<'a> for DataNodeRef<'a, 'b> {
@@ -1189,6 +1205,16 @@ unsafe impl<'a, 'b> Binding<'a> for Metadata<'a, 'b> {
     ) -> Metadata<'a, 'b> {
         Metadata { dnode, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 impl<'a, 'b> PartialEq for Metadata<'a, 'b> {

src/schema.rs

@@ -375,6 +375,16 @@ unsafe impl<'a> Binding<'a> for SchemaModule<'a> {
     ) -> SchemaModule<'_> {
         SchemaModule { context, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 impl<'a> PartialEq for SchemaModule<'a> {
@@ -967,6 +977,16 @@ unsafe impl<'a> Binding<'a> for SchemaNode<'a> {
         };
         SchemaNode { context, raw, kind }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 impl<'a> NodeIterable<'a> for SchemaNode<'a> {
@@ -1034,6 +1054,16 @@ unsafe impl<'a> Binding<'a> for SchemaStmtMust<'a> {
             _marker: std::marker::PhantomData,
         }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 unsafe impl Send for SchemaStmtMust<'_> {}
@@ -1069,6 +1099,18 @@ unsafe impl<'a> Binding<'a> for SchemaStmtWhen<'a> {
             _marker: std::marker::PhantomData,
         }
     }
+
+    unsafe fn into_raw(mut self) -> *mut Self::CType {
+        // This isn't the actual pointer originally returned by libyang, but it
+        // shouldn't matter.
+        let raw = std::ptr::addr_of_mut!(self.raw);
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 unsafe impl Send for SchemaStmtWhen<'_> {}
@@ -1114,6 +1156,16 @@ unsafe impl<'a> Binding<'a> for SchemaLeafType<'a> {
     ) -> SchemaLeafType<'_> {
         SchemaLeafType { context, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 unsafe impl Send for SchemaLeafType<'_> {}
@@ -1213,6 +1265,16 @@ unsafe impl<'a> Binding<'a> for SchemaExtInstance<'a> {
     ) -> SchemaExtInstance<'_> {
         SchemaExtInstance { context, raw }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType {
+        let raw = self.raw;
+        #[allow(clippy::forget_non_drop)]
+        // Allow the forget here despite DataNodeRef not having a Drop impl. If
+        // a Drop impl ever is added, we don't want this to start behaving
+        // incorrectly.
+        std::mem::forget(self);
+        raw
+    }
 }
 
 unsafe impl Send for SchemaExtInstance<'_> {}

src/utils.rs

@@ -60,4 +60,6 @@ where
             Some(Self::from_raw(container, raw))
         }
     }
+
+    unsafe fn into_raw(self) -> *mut Self::CType;
 }