From: Matt Corallo <649246+TheBlueMatt@users.noreply.github.com> Date: Wed, 23 Mar 2022 20:23:23 +0000 (+0000) Subject: Merge pull request #63 from TheBlueMatt/main X-Git-Tag: v0.0.105.2^0 X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=commitdiff_plain;h=95615c72597d5684e4314dae6e1e01170cd1a435;hp=eb231dca2c899c983d212bcceab5dacef4e0c1e0 Merge pull request #63 from TheBlueMatt/main Consider all reference types clonable + handle refs-in-tuples --- diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index e97fb65..0e1617a 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -272,14 +272,22 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, writeln!(w, "pub struct {} {{", mangled_container).unwrap(); for (idx, ty) in types.iter().enumerate() { writeln!(w, "\t/// The element at position {}", idx).unwrap(); - writeln!(w, "\tpub {}: {},", ('a' as u8 + idx as u8) as char, ty).unwrap(); + if ty.starts_with("&'static ") { + writeln!(w, "\tpub {}: {},", ('a' as u8 + idx as u8) as char, &ty[9..]).unwrap(); + } else { + writeln!(w, "\tpub {}: {},", ('a' as u8 + idx as u8) as char, ty).unwrap(); + } } writeln!(w, "}}").unwrap(); let mut tuple_str = "(".to_owned(); for (idx, ty) in types.iter().enumerate() { if idx != 0 { tuple_str += ", "; } - tuple_str += ty; + if ty.starts_with("&'static ") { + tuple_str += &ty[9..]; + } else { + tuple_str += ty; + } } tuple_str += ")"; @@ -306,8 +314,14 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, writeln!(w, "impl Clone for {} {{", mangled_container).unwrap(); writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); writeln!(w, "\t\tSelf {{").unwrap(); - for idx in 0..types.len() { - writeln!(w, "\t\t\t{}: Clone::clone(&self.{}),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap(); + for (idx, ty) in types.iter().enumerate() { + if ty.starts_with("&'static ") { + // Assume blindly the type is opaque. If its not we'll fail to build. + // Really we should never have derived structs with a reference type. + write!(w, "\t\t\t{}: {} {{ inner: self.{}.inner, is_owned: false}},", ('a' as u8 + idx as u8) as char, &ty[9..], ('a' as u8 + idx as u8) as char).unwrap(); + } else{ + writeln!(w, "\t\t\t{}: Clone::clone(&self.{}),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap(); + } } writeln!(w, "\t\t}}").unwrap(); writeln!(w, "\t}}").unwrap(); @@ -327,8 +341,14 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, } writeln!(w, ") -> {} {{", mangled_container).unwrap(); write!(w, "\t{} {{ ", mangled_container).unwrap(); - for idx in 0..types.len() { - write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap(); + for (idx, ty) in types.iter().enumerate() { + if ty.starts_with("&'static ") { + // Assume blindly the type is opaque. If its not we'll fail to build. + // Really we should never have derived structs with a reference type. + write!(w, "{}: {} {{ inner: {}.inner, is_owned: false}}, ", ('a' as u8 + idx as u8) as char, &ty[9..], ('a' as u8 + idx as u8) as char).unwrap(); + } else { + write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap(); + } } writeln!(w, "}}\n}}\n").unwrap(); diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 2efba6e..51a5dfc 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -772,6 +772,7 @@ impl<'a> CrateTypes<'a> { self.clonable_types.borrow_mut().insert(object); } pub fn is_clonable(&self, object: &str) -> bool { + object.starts_with("&'static ") || self.clonable_types.borrow().contains(object) } pub fn write_new_template(&self, mangled_container: String, has_destructor: bool, created_container: &[u8]) { diff --git a/lightning-c-bindings/include/lightning.h b/lightning-c-bindings/include/lightning.h index 7274897..9b2fefe 100644 --- a/lightning-c-bindings/include/lightning.h +++ b/lightning-c-bindings/include/lightning.h @@ -4319,7 +4319,7 @@ typedef struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ { /** * The element at position 1 */ - const struct LDKNetworkGraph *NONNULL_PTR b; + struct LDKNetworkGraph b; } LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ; @@ -13407,6 +13407,12 @@ void CResult_ProbabilisticScoringParametersDecodeErrorZ_free(struct LDKCResult_P */ struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ProbabilisticScoringParametersDecodeErrorZ *NONNULL_PTR orig); +/** + * Creates a new tuple which has the same data as `orig` + * but with all dynamically-allocated buffers duplicated in new buffers. + */ +struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone(const struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ *NONNULL_PTR orig); + /** * Creates a new C2Tuple_ProbabilisticScoringParametersNetworkGraphZ from the contained elements. */ diff --git a/lightning-c-bindings/src/c_types/derived.rs b/lightning-c-bindings/src/c_types/derived.rs index 6c18446..62c6ccc 100644 --- a/lightning-c-bindings/src/c_types/derived.rs +++ b/lightning-c-bindings/src/c_types/derived.rs @@ -3963,10 +3963,10 @@ pub struct C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { /// The element at position 0 pub a: crate::lightning::routing::scoring::ProbabilisticScoringParameters, /// The element at position 1 - pub b: &'static crate::lightning::routing::network_graph::NetworkGraph, + pub b: crate::lightning::routing::network_graph::NetworkGraph, } -impl From<(crate::lightning::routing::scoring::ProbabilisticScoringParameters, &'static crate::lightning::routing::network_graph::NetworkGraph)> for C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - fn from (tup: (crate::lightning::routing::scoring::ProbabilisticScoringParameters, &'static crate::lightning::routing::network_graph::NetworkGraph)) -> Self { +impl From<(crate::lightning::routing::scoring::ProbabilisticScoringParameters, crate::lightning::routing::network_graph::NetworkGraph)> for C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { + fn from (tup: (crate::lightning::routing::scoring::ProbabilisticScoringParameters, crate::lightning::routing::network_graph::NetworkGraph)) -> Self { Self { a: tup.0, b: tup.1, @@ -3974,14 +3974,25 @@ impl From<(crate::lightning::routing::scoring::ProbabilisticScoringParameters, & } } impl C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::routing::scoring::ProbabilisticScoringParameters, &'static crate::lightning::routing::network_graph::NetworkGraph) { + #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::lightning::routing::scoring::ProbabilisticScoringParameters, crate::lightning::routing::network_graph::NetworkGraph) { (self.a, self.b) } } +impl Clone for C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { + fn clone(&self) -> Self { + Self { + a: Clone::clone(&self.a), + b: crate::lightning::routing::network_graph::NetworkGraph { inner: self.b.inner, is_owned: false}, } + } +} +#[no_mangle] +/// Creates a new tuple which has the same data as `orig` +/// but with all dynamically-allocated buffers duplicated in new buffers. +pub extern "C" fn C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_clone(orig: &C2Tuple_ProbabilisticScoringParametersNetworkGraphZ) -> C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { Clone::clone(&orig) } /// Creates a new C2Tuple_ProbabilisticScoringParametersNetworkGraphZ from the contained elements. #[no_mangle] pub extern "C" fn C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_new(a: crate::lightning::routing::scoring::ProbabilisticScoringParameters, b: &'static crate::lightning::routing::network_graph::NetworkGraph) -> C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { a, b, } + C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { a, b: crate::lightning::routing::network_graph::NetworkGraph { inner: b.inner, is_owned: false}, } } #[no_mangle]