Add missing `rustc` `metadata` override for `lightning_types`

[ldk-c-bindings] / lightning-c-bindings / src / lightning / ln / wire.rs

diff --git a/lightning-c-bindings/src/lightning/ln/wire.rs b/lightning-c-bindings/src/lightning/ln/wire.rs
index 7237de2818550ceb35f9694c51d3862d3e66a647..e5747f69225e3a518db9f37ea562125abd7eec60 100644 (file)
--- a/lightning-c-bindings/src/lightning/ln/wire.rs
+++ b/lightning-c-bindings/src/lightning/ln/wire.rs
@@ -8,10 +8,11 @@
 
 //! Wire encoding/decoding for Lightning messages according to [BOLT #1], and for
 //! custom message through the [`CustomMessageReader`] trait.
 
 //! Wire encoding/decoding for Lightning messages according to [BOLT #1], and for
 //! custom message through the [`CustomMessageReader`] trait.

-//! 
+//!

 //! [BOLT #1]: https://github.com/lightning/bolts/blob/master/01-messaging.md
 
 use alloc::str::FromStr;
 //! [BOLT #1]: https://github.com/lightning/bolts/blob/master/01-messaging.md
 
 use alloc::str::FromStr;

+use alloc::string::String;

 use core::ffi::c_void;
 use core::convert::Infallible;
 use bitcoin::hashes::Hash;
 use core::ffi::c_void;
 use core::convert::Infallible;
 use bitcoin::hashes::Hash;


@@ -30,7 +31,6 @@ pub struct CustomMessageReader {
        /// implementation and the message could be decoded, must return `Ok(Some(message))`. If the
        /// message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
        /// occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
        /// implementation and the message could be decoded, must return `Ok(Some(message))`. If the
        /// message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
        /// occur, must return `Err(DecodeError::X)` where `X` details the encountered error.

-       #[must_use]

        pub read: extern "C" fn (this_arg: *const c_void, message_type: u16, buffer: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_TypeZDecodeErrorZ,
        /// Frees any resources associated with this object given its this_arg pointer.
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub read: extern "C" fn (this_arg: *const c_void, message_type: u16, buffer: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_TypeZDecodeErrorZ,
        /// Frees any resources associated with this object given its this_arg pointer.
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.


@@ -38,8 +38,8 @@ pub struct CustomMessageReader {
 }
 unsafe impl Send for CustomMessageReader {}
 unsafe impl Sync for CustomMessageReader {}
 }
 unsafe impl Send for CustomMessageReader {}
 unsafe impl Sync for CustomMessageReader {}

-#[no_mangle]
-pub(crate) extern "C" fn CustomMessageReader_clone_fields(orig: &CustomMessageReader) -> CustomMessageReader {
+#[allow(unused)]
+pub(crate) fn CustomMessageReader_clone_fields(orig: &CustomMessageReader) -> CustomMessageReader {

        CustomMessageReader {
                this_arg: orig.this_arg,
                read: Clone::clone(&orig.read),
        CustomMessageReader {
                this_arg: orig.this_arg,
                read: Clone::clone(&orig.read),


@@ -52,7 +52,17 @@ impl rustCustomMessageReader for CustomMessageReader {
        type CustomMessage = crate::lightning::ln::wire::Type;
        fn read<R:crate::c_types::io::Read>(&self, mut message_type: u16, mut buffer: &mut R) -> Result<Option<crate::lightning::ln::wire::Type>, lightning::ln::msgs::DecodeError> {
                let mut ret = (self.read)(self.this_arg, message_type, crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec(buffer)));
        type CustomMessage = crate::lightning::ln::wire::Type;
        fn read<R:crate::c_types::io::Read>(&self, mut message_type: u16, mut buffer: &mut R) -> Result<Option<crate::lightning::ln::wire::Type>, lightning::ln::msgs::DecodeError> {
                let mut ret = (self.read)(self.this_arg, message_type, crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec(buffer)));

-               let mut local_ret = match ret.result_ok { true => Ok( { let mut local_ret_0 = { /* (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ let ret_0_opt = (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }); { } if ret_0_opt.is_none() { None } else { Some({ ret_0_opt.take() }) } }; local_ret_0 }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
+               let mut local_ret = match ret.result_ok { true => Ok( { let mut local_ret_0 = { /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ let ret_0_opt = (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }); if ret_0_opt.is_none() { None } else { Some({ { { ret_0_opt.take() } }})} }; local_ret_0 }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).into_native() })};
+               local_ret
+       }
+}
+
+pub struct CustomMessageReaderRef(CustomMessageReader);
+impl rustCustomMessageReader for CustomMessageReaderRef {
+       type CustomMessage = crate::lightning::ln::wire::Type;
+       fn read<R:crate::c_types::io::Read>(&self, mut message_type: u16, mut buffer: &mut R) -> Result<Option<crate::lightning::ln::wire::Type>, lightning::ln::msgs::DecodeError> {
+               let mut ret = (self.0.read)(self.0.this_arg, message_type, crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec(buffer)));
+               let mut local_ret = match ret.result_ok { true => Ok( { let mut local_ret_0 = { /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ let ret_0_opt = (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }); if ret_0_opt.is_none() { None } else { Some({ { { ret_0_opt.take() } }})} }; local_ret_0 }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).into_native() })};

                local_ret
        }
 }
                local_ret
        }
 }


@@ -60,9 +70,14 @@ impl rustCustomMessageReader for CustomMessageReader {
 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 // directly as a Deref trait in higher-level structs:
 impl core::ops::Deref for CustomMessageReader {
 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 // directly as a Deref trait in higher-level structs:
 impl core::ops::Deref for CustomMessageReader {

-       type Target = Self;
-       fn deref(&self) -> &Self {
-               self
+       type Target = CustomMessageReaderRef;
+       fn deref(&self) -> &Self::Target {
+               unsafe { &*(self as *const _ as *const CustomMessageReaderRef) }
+       }
+}
+impl core::ops::DerefMut for CustomMessageReader {
+       fn deref_mut(&mut self) -> &mut CustomMessageReaderRef {
+               unsafe { &mut *(self as *mut _ as *mut CustomMessageReaderRef) }

        }
 }
 /// Calls the free function if one is set
        }
 }
 /// Calls the free function if one is set


@@ -78,6 +93,7 @@ impl Drop for CustomMessageReader {
 mod encode {
 
 use alloc::str::FromStr;
 mod encode {
 
 use alloc::str::FromStr;

+use alloc::string::String;

 use core::ffi::c_void;
 use core::convert::Infallible;
 use bitcoin::hashes::Hash;
 use core::ffi::c_void;
 use core::convert::Infallible;
 use bitcoin::hashes::Hash;


@@ -95,25 +111,29 @@ pub struct Type {
        /// This has no meaning in the LDK, and can be NULL or any other value.
        pub this_arg: *mut c_void,
        /// Returns the type identifying the message payload.
        /// This has no meaning in the LDK, and can be NULL or any other value.
        pub this_arg: *mut c_void,
        /// Returns the type identifying the message payload.

-       #[must_use]

        pub type_id: extern "C" fn (this_arg: *const c_void) -> u16,
        /// Return a human-readable "debug" string describing this object
        pub debug_str: extern "C" fn (this_arg: *const c_void) -> crate::c_types::Str,
        /// Serialize the object into a byte array
        pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
        pub type_id: extern "C" fn (this_arg: *const c_void) -> u16,
        /// Return a human-readable "debug" string describing this object
        pub debug_str: extern "C" fn (this_arg: *const c_void) -> crate::c_types::Str,
        /// Serialize the object into a byte array
        pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,

+       /// Called, if set, after this Type has been cloned into a duplicate object.
+       /// The new Type is provided, and should be mutated as needed to perform a
+       /// deep copy of the object pointed to by this_arg or avoid any double-freeing.
+       pub cloned: Option<extern "C" fn (new_Type: &mut Type)>,

        /// Frees any resources associated with this object given its this_arg pointer.
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
 unsafe impl Send for Type {}
 unsafe impl Sync for Type {}
        /// Frees any resources associated with this object given its this_arg pointer.
        /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
        pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 }
 unsafe impl Send for Type {}
 unsafe impl Sync for Type {}

-#[no_mangle]
-pub(crate) extern "C" fn Type_clone_fields(orig: &Type) -> Type {
+#[allow(unused)]
+pub(crate) fn Type_clone_fields(orig: &Type) -> Type {

        Type {
                this_arg: orig.this_arg,
                type_id: Clone::clone(&orig.type_id),
                debug_str: Clone::clone(&orig.debug_str),
                write: Clone::clone(&orig.write),
        Type {
                this_arg: orig.this_arg,
                type_id: Clone::clone(&orig.type_id),
                debug_str: Clone::clone(&orig.debug_str),
                write: Clone::clone(&orig.write),

+               cloned: Clone::clone(&orig.cloned),

                free: Clone::clone(&orig.free),
        }
 }
                free: Clone::clone(&orig.free),
        }
 }


@@ -122,12 +142,40 @@ impl core::fmt::Debug for Type {
                f.write_str((self.debug_str)(self.this_arg).into_str())
        }
 }
                f.write_str((self.debug_str)(self.this_arg).into_str())
        }
 }

+impl core::fmt::Debug for TypeRef {
+       fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+               f.write_str((self.0.debug_str)(self.0.this_arg).into_str())
+       }
+}

 impl lightning::util::ser::Writeable for Type {
        fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {
                let vec = (self.write)(self.this_arg);
                w.write_all(vec.as_slice())
        }
 }
 impl lightning::util::ser::Writeable for Type {
        fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {
                let vec = (self.write)(self.this_arg);
                w.write_all(vec.as_slice())
        }
 }

+impl lightning::util::ser::Writeable for TypeRef {
+       fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {
+               let vec = (self.0.write)(self.0.this_arg);
+               w.write_all(vec.as_slice())
+       }
+}
+#[no_mangle]
+/// Creates a copy of a Type
+pub extern "C" fn Type_clone(orig: &Type) -> Type {
+       let mut res = Type_clone_fields(orig);
+       if let Some(f) = orig.cloned { (f)(&mut res) };
+       res
+}
+impl Clone for Type {
+       fn clone(&self) -> Self {
+               Type_clone(self)
+       }
+}
+impl Clone for TypeRef {
+       fn clone(&self) -> Self {
+               Self(Type_clone(&self.0))
+       }
+}

 
 use lightning::ln::wire::Type as rustType;
 impl rustType for Type {
 
 use lightning::ln::wire::Type as rustType;
 impl rustType for Type {


@@ -137,12 +185,25 @@ impl rustType for Type {
        }
 }
 
        }
 }
 

+pub struct TypeRef(Type);
+impl rustType for TypeRef {
+       fn type_id(&self) -> u16 {
+               let mut ret = (self.0.type_id)(self.0.this_arg);
+               ret
+       }
+}
+

 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 // directly as a Deref trait in higher-level structs:
 impl core::ops::Deref for Type {
 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 // directly as a Deref trait in higher-level structs:
 impl core::ops::Deref for Type {

-       type Target = Self;
-       fn deref(&self) -> &Self {
-               self
+       type Target = TypeRef;
+       fn deref(&self) -> &Self::Target {
+               unsafe { &*(self as *const _ as *const TypeRef) }
+       }
+}
+impl core::ops::DerefMut for Type {
+       fn deref_mut(&mut self) -> &mut TypeRef {
+               unsafe { &mut *(self as *mut _ as *mut TypeRef) }

        }
 }
 /// Calls the free function if one is set
        }
 }
 /// Calls the free function if one is set