From: Matt Corallo <649246+TheBlueMatt@users.noreply.github.com> Date: Wed, 30 Mar 2022 17:16:02 +0000 (+0000) Subject: Merge pull request #67 from TheBlueMatt/main X-Git-Tag: v0.0.106.0~2 X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=commitdiff_plain;h=f6b1c7c987d6fe7e2baab6f104a0adc291fa67a0;hp=95615c72597d5684e4314dae6e1e01170cd1a435 Merge pull request #67 from TheBlueMatt/main Redo tuple-reference mapping and prep for 106 --- diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 4bb3188..9387a7f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -27,7 +27,7 @@ jobs: touch src/version.rs RUSTFLAGS="--cfg=c_bindings" cargo check --features std - name: Install cbindgen - run: cargo install --force cbindgen + run: cargo install --version 0.20.0 cbindgen - name: Checkout Rust-Lightning git run: | git clone https://github.com/rust-bitcoin/rust-lightning @@ -78,7 +78,7 @@ jobs: with: fetch-depth: 0 - name: Install cbindgen - run: cargo install --force cbindgen + run: cargo install --version 0.20.0 cbindgen - name: Checkout Rust-Lightning git run: | git clone https://github.com/rust-bitcoin/rust-lightning diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 0e1617a..e97fb65 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -272,22 +272,14 @@ 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(); - 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, "\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 += ", "; } - if ty.starts_with("&'static ") { - tuple_str += &ty[9..]; - } else { - tuple_str += ty; - } + tuple_str += ty; } tuple_str += ")"; @@ -314,14 +306,8 @@ 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, 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(); - } + 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(); } writeln!(w, "\t\t}}").unwrap(); writeln!(w, "\t}}").unwrap(); @@ -341,14 +327,8 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, } writeln!(w, ") -> {} {{", mangled_container).unwrap(); write!(w, "\t{} {{ ", mangled_container).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(); - } + for idx in 0..types.len() { + write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap(); } writeln!(w, "}}\n}}\n").unwrap(); diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index fbe3c99..d62b2a3 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -102,24 +102,44 @@ fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path let mut arg_conv = Vec::new(); if t == "lightning::util::ser::ReadableArgs" { - write!(w, ", arg: ").unwrap(); assert!(trait_path.leading_colon.is_none()); let args_seg = trait_path.segments.iter().last().unwrap(); assert_eq!(format!("{}", args_seg.ident), "ReadableArgs"); if let syn::PathArguments::AngleBracketed(args) = &args_seg.arguments { assert_eq!(args.args.len(), 1); if let syn::GenericArgument::Type(args_ty) = args.args.iter().next().unwrap() { - types.write_c_type(w, args_ty, Some(generics), false); + macro_rules! write_arg_conv { + ($ty: expr, $arg_name: expr) => { + write!(w, ", {}: ", $arg_name).unwrap(); + types.write_c_type(w, $ty, Some(generics), false); + + write!(&mut arg_conv, "\t").unwrap(); + if types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("{}", $arg_name), &$ty, Some(generics)) { + write!(&mut arg_conv, "\n\t").unwrap(); + } - write!(&mut arg_conv, "\t").unwrap(); - if types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("arg"), &args_ty, Some(generics)) { - write!(&mut arg_conv, "\n\t").unwrap(); + write!(&mut arg_conv, "let {}_conv = ", $arg_name).unwrap(); + types.write_from_c_conversion_prefix(&mut arg_conv, &$ty, Some(generics)); + write!(&mut arg_conv, "{}", $arg_name).unwrap(); + types.write_from_c_conversion_suffix(&mut arg_conv, &$ty, Some(generics)); + write!(&mut arg_conv, ";\n").unwrap(); + } } - write!(&mut arg_conv, "let arg_conv = ").unwrap(); - types.write_from_c_conversion_prefix(&mut arg_conv, &args_ty, Some(generics)); - write!(&mut arg_conv, "arg").unwrap(); - types.write_from_c_conversion_suffix(&mut arg_conv, &args_ty, Some(generics)); + if let syn::Type::Tuple(tup) = args_ty { + // Crack open tuples and make them separate arguments instead of + // converting the full tuple. This makes it substantially easier to + // reason about things like references in the tuple fields. + let mut arg_conv_res = Vec::new(); + for (idx, elem) in tup.elems.iter().enumerate() { + let arg_name = format!("arg_{}", ('a' as u8 + idx as u8) as char); + write_arg_conv!(elem, arg_name); + write!(&mut arg_conv_res, "{}_conv{}", arg_name, if idx != tup.elems.len() - 1 { ", " } else { "" }).unwrap(); + } + writeln!(&mut arg_conv, "\tlet arg_conv = ({});", String::from_utf8(arg_conv_res).unwrap()).unwrap(); + } else { + write_arg_conv!(args_ty, "arg"); + } } else { unreachable!(); } } else { unreachable!(); } } else if t == "lightning::util::ser::MaybeReadable" { @@ -131,7 +151,6 @@ fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path if t == "lightning::util::ser::ReadableArgs" { w.write(&arg_conv).unwrap(); - write!(w, ";\n").unwrap(); } write!(w, "\tlet res: ").unwrap(); diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 51a5dfc..ced1f34 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -772,7 +772,6 @@ 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]) { @@ -1365,14 +1364,17 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } }, "Option" => { + let mut is_contained_ref = false; let contained_struct = if let Some(syn::Type::Path(p)) = single_contained { Some(self.resolve_path(&p.path, generics)) } else if let Some(syn::Type::Reference(r)) = single_contained { + is_contained_ref = true; if let syn::Type::Path(p) = &*r.elem { Some(self.resolve_path(&p.path, generics)) } else { None } } else { None }; if let Some(inner_path) = contained_struct { + let only_contained_has_inner = self.c_type_has_inner_from_path(&inner_path); if self.c_type_has_inner_from_path(&inner_path) { let is_inner_ref = if let Some(syn::Type::Reference(_)) = single_contained { true } else { false }; if is_ref { @@ -1386,12 +1388,19 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { ], " }", ContainerPrefixLocation::OutsideConv)); } } else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() { - let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap(); - return Some(("if ", vec![ - (format!(".is_none() {{ {}::None }} else {{ {}::Some(", - inner_name, inner_name), - format!("{}.unwrap()", var_access)) - ], ") }", ContainerPrefixLocation::PerConv)); + if self.is_primitive(&inner_path) || (!is_contained_ref && !is_ref) || only_contained_has_inner { + let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap(); + return Some(("if ", vec![ + (format!(".is_none() {{ {}::None }} else {{ {}::Some(", inner_name, inner_name), + format!("{}.unwrap()", var_access)) + ], ") }", ContainerPrefixLocation::PerConv)); + } else { + let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap(); + return Some(("if ", vec![ + (format!(".is_none() {{ {}::None }} else {{ {}::Some(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */", inner_name, inner_name), + format!("{}.clone().unwrap()", var_access)) + ], ") }", ContainerPrefixLocation::PerConv)); + } } else { // If c_type_from_path is some (ie there's a manual mapping for the inner // type), lean on write_empty_rust_val, below. @@ -1432,6 +1441,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // Returns prefix + Vec<(prefix, var-name-to-inline-convert)> + suffix // expecting one element in the vec per generic type, each of which is inline-converted -> Option<(&'b str, Vec<(String, String)>, &'b str, ContainerPrefixLocation)> { + let mut only_contained_has_inner = false; + let only_contained_resolved = if let Some(syn::Type::Path(p)) = single_contained { + let res = self.resolve_path(&p.path, generics); + only_contained_has_inner = self.c_type_has_inner_from_path(&res); + Some(res) + } else { None }; match full_path { "Result" if !is_ref => { Some(("match ", @@ -1439,18 +1454,17 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_access))], ")}", ContainerPrefixLocation::PerConv)) }, - "Slice" if is_ref => { + "Slice" if is_ref && only_contained_has_inner => { Some(("Vec::new(); for mut item in ", vec![(format!(".as_slice().iter() {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv)) }, "Vec"|"Slice" => { Some(("Vec::new(); for mut item in ", vec![(format!(".into_rust().drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv)) }, "Option" => { - if let Some(syn::Type::Path(p)) = single_contained { - let inner_path = self.resolve_path(&p.path, generics); - if self.is_primitive(&inner_path) { + if let Some(resolved) = only_contained_resolved { + if self.is_primitive(&resolved) { return Some(("if ", vec![(".is_some() { Some(".to_string(), format!("{}.take()", var_access))], ") } else { None }", ContainerPrefixLocation::NoPrefix)) - } else if self.c_type_has_inner_from_path(&inner_path) { + } else if only_contained_has_inner { if is_ref { return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_access))], ").clone()) }", ContainerPrefixLocation::PerConv)) } else { @@ -2161,7 +2175,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } } - if let Some((prefix, conversions, suffix, prefix_location)) = container_lookup(&$container_type, is_ref && ty_has_inner, only_contained_type, ident, var) { + if let Some((prefix, conversions, suffix, prefix_location)) = container_lookup(&$container_type, is_ref, only_contained_type, ident, var) { assert_eq!(conversions.len(), $args_len); write!(w, "let mut local_{}{} = ", ident, if (!to_c && needs_ref_map) || (to_c && $container_type == "Option" && contains_slice) {"_base"} else { "" }).unwrap(); @@ -2373,7 +2387,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } pub fn write_to_c_conversion_new_var_inner(&self, w: &mut W, ident: &syn::Ident, var_access: &str, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool, from_ownable_ref: bool) -> bool { - self.write_conversion_new_var_intern(w, ident, var_access, t, generics, false, ptr_for_ref, true, from_ownable_ref, + self.write_conversion_new_var_intern(w, ident, var_access, t, generics, from_ownable_ref, ptr_for_ref, true, from_ownable_ref, &|a, b| self.to_c_conversion_new_var_from_path(a, b), &|a, b, c, d, e| self.to_c_conversion_container_new_var(generics, a, b, c, d, e), // We force ptr_for_ref here since we can't generate a ref on one line and use it later @@ -2700,7 +2714,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if !c_ty { self.write_rust_path(w, generics, path); } else { - write!(w, "{}", full_path).unwrap(); + // We shouldn't be mapping references in types, so panic here + unimplemented!(); } } else if is_ref { write!(w, "&{}{}{}", if is_mut { "mut " } else { "" }, crate_pfx, full_path).unwrap(); diff --git a/genbindings.sh b/genbindings.sh index 9cc35ad..25bf60f 100755 --- a/genbindings.sh +++ b/genbindings.sh @@ -50,13 +50,15 @@ elif [ "$HOST_PLATFORM" = "host: aarch64-apple-darwin" ]; then HOST_OSX=true fi +BASE_HOST_CFLAGS="$BASE_CFLAGS" + if [ "$HOST_OSX" = "true" ]; then export MACOSX_DEPLOYMENT_TARGET=10.9 LOCAL_CFLAGS="$LOCAL_CFLAGS -isysroot$(xcrun --show-sdk-path) -mmacosx-version-min=10.9" - BASE_CFLAGS="$BASE_CFLAGS -isysroot$(xcrun --show-sdk-path) -mmacosx-version-min=10.9" + BASE_HOST_CFLAGS="$BASE_HOST_CFLAGS -isysroot$(xcrun --show-sdk-path) -mmacosx-version-min=10.9" # Targeting aarch64 appears to be supported only starting with Big Sur, so check it before use - clang -o /dev/null $BASE_CFLAGS --target=aarch64-apple-darwin -mcpu=apple-a14 genbindings_path_map_test_file.c && - export CFLAGS_aarch64_apple_darwin="$BASE_CFLAGS --target=aarch64-apple-darwin -mcpu=apple-a14" || + clang -o /dev/null $BASE_HOST_CFLAGS --target=aarch64-apple-darwin -mcpu=apple-a14 genbindings_path_map_test_file.c && + export CFLAGS_aarch64_apple_darwin="$BASE_HOST_CFLAGS --target=aarch64-apple-darwin -mcpu=apple-a14" || echo "WARNING: Can not build targeting aarch64-apple-darin. Upgrade to Big Sur or try upstream clang" fi @@ -66,12 +68,12 @@ ENV_TARGET=$(rustc --version --verbose | grep host | awk '{ print $2 }' | sed 's case "$ENV_TARGET" in "x86_64"*) export RUSTFLAGS="$BASE_RUSTFLAGS -C target-cpu=sandybridge" - export CFLAGS_$ENV_TARGET="$BASE_CFLAGS -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" + export CFLAGS_$ENV_TARGET="$BASE_HOST_CFLAGS -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" ;; *) # Assume this isn't targeted at another host and build for the host's CPU. export RUSTFLAGS="$BASE_RUSTFLAGS -C target-cpu=native" - export CFLAGS_$ENV_TARGET="$BASE_CFLAGS -mcpu=native" + export CFLAGS_$ENV_TARGET="$BASE_HOST_CFLAGS -mcpu=native" ;; esac @@ -305,7 +307,7 @@ fi gcc $LOCAL_CFLAGS -fPIC -std=c99 -Wall -g -pthread -I../ldk-net ../ldk-net/ldk_net.c -c -o ldk_net.o if [ "$2" = "true" ]; then g++ $LOCAL_CFLAGS -std=c++11 -Wall -g -pthread -DREAL_NET -I../ldk-net ldk_net.o demo.cpp target/debug/libldk.a -ldl -lm - if [ -x "`which valgrind`" ]; then + if [ -x "`which valgrind`" -a "$(uname -m)" != "ppc64le" ]; then valgrind --error-exitcode=4 --memcheck:leak-check=full --show-leak-kinds=all ./a.out echo else @@ -483,7 +485,7 @@ if [ "$CLANGPP" != "" ]; then # The cc-rs crate tries to force -fdata-sections and -ffunction-sections on, which # breaks -fembed-bitcode, so we turn off cc-rs' default flags and specify exactly # what we want here. - export CFLAGS_$ENV_TARGET="$BASE_CFLAGS -fPIC -fembed-bitcode -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" + export CFLAGS_$ENV_TARGET="$BASE_HOST_CFLAGS -fPIC -fembed-bitcode -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" export CRATE_CC_NO_DEFAULTS=true fi @@ -534,7 +536,7 @@ if [ "$CLANGPP" != "" -a "$LLD" != "" ]; then LINK_ARG_FLAGS="$LINK_ARG_FLAGS -C link-arg="-isysroot$(xcrun --show-sdk-path)" -C link-arg=-mmacosx-version-min=10.9" RUSTFLAGS="$BASE_RUSTFLAGS -C target-cpu=apple-a14 -C embed-bitcode=yes -C linker-plugin-lto -C lto -C linker=$CLANG $LINK_ARG_FLAGS -C link-arg=-mcpu=apple-a14" CARGO_PROFILE_RELEASE_LTO=true cargo build $CARGO_BUILD_ARGS -v --release --target aarch64-apple-darwin fi - export CFLAGS_$ENV_TARGET="$BASE_CFLAGS -O3 -fPIC -fembed-bitcode -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" + export CFLAGS_$ENV_TARGET="$BASE_HOST_CFLAGS -O3 -fPIC -fembed-bitcode -march=sandybridge -mcpu=sandybridge -mtune=sandybridge" # Rust doesn't recognize CFLAGS changes, so we need to clean build artifacts cargo clean --release CARGO_PROFILE_RELEASE_LTO=true RUSTFLAGS="$RUSTFLAGS -C embed-bitcode=yes -C linker-plugin-lto -C lto -C linker=$CLANG $LINK_ARG_FLAGS -C link-arg=-march=sandybridge -C link-arg=-mcpu=sandybridge -C link-arg=-mtune=sandybridge" cargo build $CARGO_BUILD_ARGS -v --release diff --git a/lightning-c-bindings/include/lightning.h b/lightning-c-bindings/include/lightning.h index 9b2fefe..99a23a0 100644 --- a/lightning-c-bindings/include/lightning.h +++ b/lightning-c-bindings/include/lightning.h @@ -4308,20 +4308,6 @@ typedef struct MUST_USE_STRUCT LDKNetworkGraph { bool is_owned; } LDKNetworkGraph; -/** - * A tuple of 2 elements. See the individual fields for the types contained. - */ -typedef struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - /** - * The element at position 0 - */ - struct LDKProbabilisticScoringParameters a; - /** - * The element at position 1 - */ - struct LDKNetworkGraph b; -} LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ; - /** @@ -13407,22 +13393,6 @@ 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. - */ -struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_new(struct LDKProbabilisticScoringParameters a, const struct LDKNetworkGraph *NONNULL_PTR b); - -/** - * Frees any resources used by the C2Tuple_ProbabilisticScoringParametersNetworkGraphZ. - */ -void C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ _res); - /** * Creates a new CResult_ProbabilisticScorerDecodeErrorZ in the success state. */ @@ -25496,7 +25466,7 @@ struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer /** * Read a ProbabilisticScorer from a byte array, created by ProbabilisticScorer_write */ -struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ arg); +struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b); /** * Frees any resources used by the FilesystemPersister, if is_owned is set and inner is non-NULL. diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp index 5a18979..58970ce 100644 --- a/lightning-c-bindings/include/lightningpp.hpp +++ b/lightning-c-bindings/include/lightningpp.hpp @@ -209,8 +209,8 @@ class CResult_ChannelReestablishDecodeErrorZ; class CResult_CommitmentSignedDecodeErrorZ; class CVec_UpdateAddHTLCZ; class CResult_UnsignedNodeAnnouncementDecodeErrorZ; -class CResult_InitFeaturesDecodeErrorZ; class COption_u32Z; +class CResult_InitFeaturesDecodeErrorZ; class CResult_StaticPaymentOutputDescriptorDecodeErrorZ; class CResult_PaymentIdPaymentSendFailureZ; class CResult_ReplyChannelRangeDecodeErrorZ; @@ -318,24 +318,23 @@ class CResult_NonePeerHandleErrorZ; class CResult_COption_EventZDecodeErrorZ; class CResult_CVec_SignatureZNoneZ; class COption_CVec_NetAddressZZ; -class C2Tuple_ProbabilisticScoringParametersNetworkGraphZ; class CResult__u832APIErrorZ; class CResult_PaymentIdPaymentErrorZ; class CResult_DescriptionCreationErrorZ; -class CResult_PayeePubKeyErrorZ; class CResult_COption_MonitorEventZDecodeErrorZ; +class CResult_PayeePubKeyErrorZ; class CVec_C2Tuple_PublicKeyTypeZZ; class CResult_RoutingFeesDecodeErrorZ; +class CResult_QueryShortChannelIdsDecodeErrorZ; class CResult_InvoiceSemanticErrorZ; class CResult_UpdateAddHTLCDecodeErrorZ; -class CResult_QueryShortChannelIdsDecodeErrorZ; +class CVec_PhantomRouteHintsZ; class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ; class CResult_NoneAPIErrorZ; class CVec_NetAddressZ; class CResult_ChannelDetailsDecodeErrorZ; class CVec_C2Tuple_usizeTransactionZZ; class CVec_PublicKeyZ; -class CVec_PhantomRouteHintsZ; class COption_MonitorEventZ; class COption_TypeZ; class CResult_COption_TypeZDecodeErrorZ; @@ -4206,21 +4205,6 @@ public: const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; } const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; } }; -class CResult_InitFeaturesDecodeErrorZ { -private: - LDKCResult_InitFeaturesDecodeErrorZ self; -public: - CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete; - CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); } - CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); } - operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; } - ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); } - CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; } - LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; } - LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; } - const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; } - const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; } -}; class COption_u32Z { private: LDKCOption_u32Z self; @@ -4236,6 +4220,21 @@ public: const LDKCOption_u32Z* operator &() const { return &self; } const LDKCOption_u32Z* operator ->() const { return &self; } }; +class CResult_InitFeaturesDecodeErrorZ { +private: + LDKCResult_InitFeaturesDecodeErrorZ self; +public: + CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete; + CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); } + CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); } + operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; } + ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); } + CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; } + LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; } + LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; } + const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; } + const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; } +}; class CResult_StaticPaymentOutputDescriptorDecodeErrorZ { private: LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self; @@ -5841,21 +5840,6 @@ public: const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; } const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; } }; -class C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { -private: - LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ self; -public: - C2Tuple_ProbabilisticScoringParametersNetworkGraphZ(const C2Tuple_ProbabilisticScoringParametersNetworkGraphZ&) = delete; - C2Tuple_ProbabilisticScoringParametersNetworkGraphZ(C2Tuple_ProbabilisticScoringParametersNetworkGraphZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ProbabilisticScoringParametersNetworkGraphZ)); } - C2Tuple_ProbabilisticScoringParametersNetworkGraphZ(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ)); } - operator LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ() && { LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ)); return res; } - ~C2Tuple_ProbabilisticScoringParametersNetworkGraphZ() { C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(self); } - C2Tuple_ProbabilisticScoringParametersNetworkGraphZ& operator=(C2Tuple_ProbabilisticScoringParametersNetworkGraphZ&& o) { C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ProbabilisticScoringParametersNetworkGraphZ)); return *this; } - LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ* operator &() { return &self; } - LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ* operator ->() { return &self; } - const LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ* operator &() const { return &self; } - const LDKC2Tuple_ProbabilisticScoringParametersNetworkGraphZ* operator ->() const { return &self; } -}; class CResult__u832APIErrorZ { private: LDKCResult__u832APIErrorZ self; @@ -5901,21 +5885,6 @@ public: const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; } const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; } }; -class CResult_PayeePubKeyErrorZ { -private: - LDKCResult_PayeePubKeyErrorZ self; -public: - CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete; - CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); } - CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); } - operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; } - ~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); } - CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; } - LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; } - LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; } - const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; } - const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; } -}; class CResult_COption_MonitorEventZDecodeErrorZ { private: LDKCResult_COption_MonitorEventZDecodeErrorZ self; @@ -5931,6 +5900,21 @@ public: const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; } const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; } }; +class CResult_PayeePubKeyErrorZ { +private: + LDKCResult_PayeePubKeyErrorZ self; +public: + CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete; + CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); } + CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); } + operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; } + ~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); } + CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; } + LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; } + LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; } + const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; } + const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; } +}; class CVec_C2Tuple_PublicKeyTypeZZ { private: LDKCVec_C2Tuple_PublicKeyTypeZZ self; @@ -5961,6 +5945,21 @@ public: const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; } const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; } }; +class CResult_QueryShortChannelIdsDecodeErrorZ { +private: + LDKCResult_QueryShortChannelIdsDecodeErrorZ self; +public: + CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete; + CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); } + CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); } + operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; } + ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); } + CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; } + LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; } + LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; } + const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; } + const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; } +}; class CResult_InvoiceSemanticErrorZ { private: LDKCResult_InvoiceSemanticErrorZ self; @@ -5991,20 +5990,20 @@ public: const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; } const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; } }; -class CResult_QueryShortChannelIdsDecodeErrorZ { +class CVec_PhantomRouteHintsZ { private: - LDKCResult_QueryShortChannelIdsDecodeErrorZ self; + LDKCVec_PhantomRouteHintsZ self; public: - CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete; - CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); } - CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); } - operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; } - ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); } - CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; } - LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; } - LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; } - const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; } - const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; } + CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete; + CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); } + CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); } + operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; } + ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); } + CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; } + LDKCVec_PhantomRouteHintsZ* operator &() { return &self; } + LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; } + const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; } + const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; } }; class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ { private: @@ -6096,21 +6095,6 @@ public: const LDKCVec_PublicKeyZ* operator &() const { return &self; } const LDKCVec_PublicKeyZ* operator ->() const { return &self; } }; -class CVec_PhantomRouteHintsZ { -private: - LDKCVec_PhantomRouteHintsZ self; -public: - CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete; - CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); } - CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); } - operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; } - ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); } - CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; } - LDKCVec_PhantomRouteHintsZ* operator &() { return &self; } - LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; } - const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; } - const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; } -}; class COption_MonitorEventZ { private: LDKCOption_MonitorEventZ self; diff --git a/lightning-c-bindings/src/c_types/derived.rs b/lightning-c-bindings/src/c_types/derived.rs index 62c6ccc..d8fd1ac 100644 --- a/lightning-c-bindings/src/c_types/derived.rs +++ b/lightning-c-bindings/src/c_types/derived.rs @@ -3958,47 +3958,6 @@ impl Clone for CResult_ProbabilisticScoringParametersDecodeErrorZ { /// but with all dynamically-allocated buffers duplicated in new buffers. pub extern "C" fn CResult_ProbabilisticScoringParametersDecodeErrorZ_clone(orig: &CResult_ProbabilisticScoringParametersDecodeErrorZ) -> CResult_ProbabilisticScoringParametersDecodeErrorZ { Clone::clone(&orig) } #[repr(C)] -/// A tuple of 2 elements. See the individual fields for the types contained. -pub struct C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - /// The element at position 0 - pub a: crate::lightning::routing::scoring::ProbabilisticScoringParameters, - /// The element at position 1 - pub b: crate::lightning::routing::network_graph::NetworkGraph, -} -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, - } - } -} -impl C2Tuple_ProbabilisticScoringParametersNetworkGraphZ { - #[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: crate::lightning::routing::network_graph::NetworkGraph { inner: b.inner, is_owned: false}, } -} - -#[no_mangle] -/// Frees any resources used by the C2Tuple_ProbabilisticScoringParametersNetworkGraphZ. -pub extern "C" fn C2Tuple_ProbabilisticScoringParametersNetworkGraphZ_free(_res: C2Tuple_ProbabilisticScoringParametersNetworkGraphZ) { } -#[repr(C)] /// The contents of CResult_ProbabilisticScorerDecodeErrorZ pub union CResult_ProbabilisticScorerDecodeErrorZPtr { /// A pointer to the contents in the success state. diff --git a/lightning-c-bindings/src/lightning/routing/scoring.rs b/lightning-c-bindings/src/lightning/routing/scoring.rs index b526a78..1a2394d 100644 --- a/lightning-c-bindings/src/lightning/routing/scoring.rs +++ b/lightning-c-bindings/src/lightning/routing/scoring.rs @@ -1007,9 +1007,10 @@ pub(crate) extern "C" fn ProbabilisticScorer_write_void(obj: *const c_void) -> c } #[no_mangle] /// Read a ProbabilisticScorer from a byte array, created by ProbabilisticScorer_write -pub extern "C" fn ProbabilisticScorer_read(ser: crate::c_types::u8slice, arg: crate::c_types::derived::C2Tuple_ProbabilisticScoringParametersNetworkGraphZ) -> crate::c_types::derived::CResult_ProbabilisticScorerDecodeErrorZ { - let (mut orig_arg_0, mut orig_arg_1) = arg.to_rust(); let mut local_arg = (*unsafe { Box::from_raw(orig_arg_0.take_inner()) }, orig_arg_1.get_native_ref()); - let arg_conv = local_arg; +pub extern "C" fn ProbabilisticScorer_read(ser: crate::c_types::u8slice, arg_a: crate::lightning::routing::scoring::ProbabilisticScoringParameters, arg_b: &crate::lightning::routing::network_graph::NetworkGraph) -> crate::c_types::derived::CResult_ProbabilisticScorerDecodeErrorZ { + let arg_a_conv = *unsafe { Box::from_raw(arg_a.take_inner()) }; + let arg_b_conv = arg_b.get_native_ref(); + let arg_conv = (arg_a_conv, arg_b_conv); let res: Result, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj_arg(ser, arg_conv); let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::scoring::ProbabilisticScorer { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() }; local_res