//! [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;
/// 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.
}
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),
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(<*mut _>::take_ptr(&mut ret.contents.err)) }).into_native() })};
+ 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
}
}
self
}
}
+impl core::ops::DerefMut for CustomMessageReader {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
/// Calls the free function if one is set
#[no_mangle]
pub extern "C" fn CustomMessageReader_free(this_ptr: CustomMessageReader) { }
mod encode {
use alloc::str::FromStr;
+use alloc::string::String;
use core::ffi::c_void;
use core::convert::Infallible;
use bitcoin::hashes::Hash;
/// 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,
+ /// 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 {}
-#[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),
+ cloned: Clone::clone(&orig.cloned),
free: Clone::clone(&orig.free),
}
}
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)
+ }
+}
use lightning::ln::wire::Type as rustType;
impl rustType for Type {
self
}
}
+impl core::ops::DerefMut for Type {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
/// Calls the free function if one is set
#[no_mangle]
pub extern "C" fn Type_free(this_ptr: Type) { }