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
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
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 += ")";
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();
}
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();
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" {
if t == "lightning::util::ser::ReadableArgs" {
w.write(&arg_conv).unwrap();
- write!(w, ";\n").unwrap();
}
write!(w, "\tlet res: ").unwrap();
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]) {
}
},
"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 {
], " }", 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<Enum> 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.
// 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 ",
("), 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 {
}
}
- 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();
}
pub fn write_to_c_conversion_new_var_inner<W: std::io::Write>(&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
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();
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
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
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
# 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
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
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;
-
/**
*/
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.
*/
/**
* 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.
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;
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;
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;
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;
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;
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;
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;
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;
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:
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;
/// 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.
}
#[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::routing::scoring::ProbabilisticScorer<&lightning::routing::network_graph::NetworkGraph>, 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
projects / ldk-c-bindings / commitdiff