2 pub union CResult_SecretKeyErrorZPtr {
3 pub result: *mut crate::c_types::SecretKey,
4 pub err: *mut crate::c_types::Secp256k1Error,
7 pub struct CResult_SecretKeyErrorZ {
8 pub contents: CResult_SecretKeyErrorZPtr,
12 pub extern "C" fn CResult_SecretKeyErrorZ_ok(o: crate::c_types::SecretKey) -> CResult_SecretKeyErrorZ {
13 CResult_SecretKeyErrorZ {
14 contents: CResult_SecretKeyErrorZPtr {
15 result: Box::into_raw(Box::new(o)),
21 pub extern "C" fn CResult_SecretKeyErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_SecretKeyErrorZ {
22 CResult_SecretKeyErrorZ {
23 contents: CResult_SecretKeyErrorZPtr {
24 err: Box::into_raw(Box::new(e)),
30 pub extern "C" fn CResult_SecretKeyErrorZ_free(_res: CResult_SecretKeyErrorZ) { }
31 impl Drop for CResult_SecretKeyErrorZ {
34 if unsafe { !(self.contents.result as *mut ()).is_null() } {
35 let _ = unsafe { Box::from_raw(self.contents.result) };
38 if unsafe { !(self.contents.err as *mut ()).is_null() } {
39 let _ = unsafe { Box::from_raw(self.contents.err) };
44 impl From<crate::c_types::CResultTempl<crate::c_types::SecretKey, crate::c_types::Secp256k1Error>> for CResult_SecretKeyErrorZ {
45 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::SecretKey, crate::c_types::Secp256k1Error>) -> Self {
46 let contents = if o.result_ok {
47 let result = unsafe { o.contents.result };
48 unsafe { o.contents.result = std::ptr::null_mut() };
49 CResult_SecretKeyErrorZPtr { result }
51 let err = unsafe { o.contents.err };
52 unsafe { o.contents.err = std::ptr::null_mut(); }
53 CResult_SecretKeyErrorZPtr { err }
57 result_ok: o.result_ok,
62 pub union CResult_PublicKeyErrorZPtr {
63 pub result: *mut crate::c_types::PublicKey,
64 pub err: *mut crate::c_types::Secp256k1Error,
67 pub struct CResult_PublicKeyErrorZ {
68 pub contents: CResult_PublicKeyErrorZPtr,
72 pub extern "C" fn CResult_PublicKeyErrorZ_ok(o: crate::c_types::PublicKey) -> CResult_PublicKeyErrorZ {
73 CResult_PublicKeyErrorZ {
74 contents: CResult_PublicKeyErrorZPtr {
75 result: Box::into_raw(Box::new(o)),
81 pub extern "C" fn CResult_PublicKeyErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_PublicKeyErrorZ {
82 CResult_PublicKeyErrorZ {
83 contents: CResult_PublicKeyErrorZPtr {
84 err: Box::into_raw(Box::new(e)),
90 pub extern "C" fn CResult_PublicKeyErrorZ_free(_res: CResult_PublicKeyErrorZ) { }
91 impl Drop for CResult_PublicKeyErrorZ {
94 if unsafe { !(self.contents.result as *mut ()).is_null() } {
95 let _ = unsafe { Box::from_raw(self.contents.result) };
98 if unsafe { !(self.contents.err as *mut ()).is_null() } {
99 let _ = unsafe { Box::from_raw(self.contents.err) };
104 impl From<crate::c_types::CResultTempl<crate::c_types::PublicKey, crate::c_types::Secp256k1Error>> for CResult_PublicKeyErrorZ {
105 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::PublicKey, crate::c_types::Secp256k1Error>) -> Self {
106 let contents = if o.result_ok {
107 let result = unsafe { o.contents.result };
108 unsafe { o.contents.result = std::ptr::null_mut() };
109 CResult_PublicKeyErrorZPtr { result }
111 let err = unsafe { o.contents.err };
112 unsafe { o.contents.err = std::ptr::null_mut(); }
113 CResult_PublicKeyErrorZPtr { err }
117 result_ok: o.result_ok,
122 pub union CResult_TxCreationKeysDecodeErrorZPtr {
123 pub result: *mut crate::ln::chan_utils::TxCreationKeys,
124 pub err: *mut crate::ln::msgs::DecodeError,
127 pub struct CResult_TxCreationKeysDecodeErrorZ {
128 pub contents: CResult_TxCreationKeysDecodeErrorZPtr,
132 pub extern "C" fn CResult_TxCreationKeysDecodeErrorZ_ok(o: crate::ln::chan_utils::TxCreationKeys) -> CResult_TxCreationKeysDecodeErrorZ {
133 CResult_TxCreationKeysDecodeErrorZ {
134 contents: CResult_TxCreationKeysDecodeErrorZPtr {
135 result: Box::into_raw(Box::new(o)),
141 pub extern "C" fn CResult_TxCreationKeysDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_TxCreationKeysDecodeErrorZ {
142 CResult_TxCreationKeysDecodeErrorZ {
143 contents: CResult_TxCreationKeysDecodeErrorZPtr {
144 err: Box::into_raw(Box::new(e)),
150 pub extern "C" fn CResult_TxCreationKeysDecodeErrorZ_free(_res: CResult_TxCreationKeysDecodeErrorZ) { }
151 impl Drop for CResult_TxCreationKeysDecodeErrorZ {
154 if unsafe { !(self.contents.result as *mut ()).is_null() } {
155 let _ = unsafe { Box::from_raw(self.contents.result) };
158 if unsafe { !(self.contents.err as *mut ()).is_null() } {
159 let _ = unsafe { Box::from_raw(self.contents.err) };
164 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::TxCreationKeys, crate::ln::msgs::DecodeError>> for CResult_TxCreationKeysDecodeErrorZ {
165 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::TxCreationKeys, crate::ln::msgs::DecodeError>) -> Self {
166 let contents = if o.result_ok {
167 let result = unsafe { o.contents.result };
168 unsafe { o.contents.result = std::ptr::null_mut() };
169 CResult_TxCreationKeysDecodeErrorZPtr { result }
171 let err = unsafe { o.contents.err };
172 unsafe { o.contents.err = std::ptr::null_mut(); }
173 CResult_TxCreationKeysDecodeErrorZPtr { err }
177 result_ok: o.result_ok,
181 impl Clone for CResult_TxCreationKeysDecodeErrorZ {
182 fn clone(&self) -> Self {
184 Self { result_ok: true, contents: CResult_TxCreationKeysDecodeErrorZPtr {
185 result: Box::into_raw(Box::new(<crate::ln::chan_utils::TxCreationKeys>::clone(unsafe { &*self.contents.result })))
188 Self { result_ok: false, contents: CResult_TxCreationKeysDecodeErrorZPtr {
189 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
195 pub extern "C" fn CResult_TxCreationKeysDecodeErrorZ_clone(orig: &CResult_TxCreationKeysDecodeErrorZ) -> CResult_TxCreationKeysDecodeErrorZ { orig.clone() }
197 pub union CResult_ChannelPublicKeysDecodeErrorZPtr {
198 pub result: *mut crate::ln::chan_utils::ChannelPublicKeys,
199 pub err: *mut crate::ln::msgs::DecodeError,
202 pub struct CResult_ChannelPublicKeysDecodeErrorZ {
203 pub contents: CResult_ChannelPublicKeysDecodeErrorZPtr,
207 pub extern "C" fn CResult_ChannelPublicKeysDecodeErrorZ_ok(o: crate::ln::chan_utils::ChannelPublicKeys) -> CResult_ChannelPublicKeysDecodeErrorZ {
208 CResult_ChannelPublicKeysDecodeErrorZ {
209 contents: CResult_ChannelPublicKeysDecodeErrorZPtr {
210 result: Box::into_raw(Box::new(o)),
216 pub extern "C" fn CResult_ChannelPublicKeysDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelPublicKeysDecodeErrorZ {
217 CResult_ChannelPublicKeysDecodeErrorZ {
218 contents: CResult_ChannelPublicKeysDecodeErrorZPtr {
219 err: Box::into_raw(Box::new(e)),
225 pub extern "C" fn CResult_ChannelPublicKeysDecodeErrorZ_free(_res: CResult_ChannelPublicKeysDecodeErrorZ) { }
226 impl Drop for CResult_ChannelPublicKeysDecodeErrorZ {
229 if unsafe { !(self.contents.result as *mut ()).is_null() } {
230 let _ = unsafe { Box::from_raw(self.contents.result) };
233 if unsafe { !(self.contents.err as *mut ()).is_null() } {
234 let _ = unsafe { Box::from_raw(self.contents.err) };
239 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::ChannelPublicKeys, crate::ln::msgs::DecodeError>> for CResult_ChannelPublicKeysDecodeErrorZ {
240 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::ChannelPublicKeys, crate::ln::msgs::DecodeError>) -> Self {
241 let contents = if o.result_ok {
242 let result = unsafe { o.contents.result };
243 unsafe { o.contents.result = std::ptr::null_mut() };
244 CResult_ChannelPublicKeysDecodeErrorZPtr { result }
246 let err = unsafe { o.contents.err };
247 unsafe { o.contents.err = std::ptr::null_mut(); }
248 CResult_ChannelPublicKeysDecodeErrorZPtr { err }
252 result_ok: o.result_ok,
256 impl Clone for CResult_ChannelPublicKeysDecodeErrorZ {
257 fn clone(&self) -> Self {
259 Self { result_ok: true, contents: CResult_ChannelPublicKeysDecodeErrorZPtr {
260 result: Box::into_raw(Box::new(<crate::ln::chan_utils::ChannelPublicKeys>::clone(unsafe { &*self.contents.result })))
263 Self { result_ok: false, contents: CResult_ChannelPublicKeysDecodeErrorZPtr {
264 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
270 pub extern "C" fn CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: &CResult_ChannelPublicKeysDecodeErrorZ) -> CResult_ChannelPublicKeysDecodeErrorZ { orig.clone() }
272 pub union CResult_TxCreationKeysErrorZPtr {
273 pub result: *mut crate::ln::chan_utils::TxCreationKeys,
274 pub err: *mut crate::c_types::Secp256k1Error,
277 pub struct CResult_TxCreationKeysErrorZ {
278 pub contents: CResult_TxCreationKeysErrorZPtr,
282 pub extern "C" fn CResult_TxCreationKeysErrorZ_ok(o: crate::ln::chan_utils::TxCreationKeys) -> CResult_TxCreationKeysErrorZ {
283 CResult_TxCreationKeysErrorZ {
284 contents: CResult_TxCreationKeysErrorZPtr {
285 result: Box::into_raw(Box::new(o)),
291 pub extern "C" fn CResult_TxCreationKeysErrorZ_err(e: crate::c_types::Secp256k1Error) -> CResult_TxCreationKeysErrorZ {
292 CResult_TxCreationKeysErrorZ {
293 contents: CResult_TxCreationKeysErrorZPtr {
294 err: Box::into_raw(Box::new(e)),
300 pub extern "C" fn CResult_TxCreationKeysErrorZ_free(_res: CResult_TxCreationKeysErrorZ) { }
301 impl Drop for CResult_TxCreationKeysErrorZ {
304 if unsafe { !(self.contents.result as *mut ()).is_null() } {
305 let _ = unsafe { Box::from_raw(self.contents.result) };
308 if unsafe { !(self.contents.err as *mut ()).is_null() } {
309 let _ = unsafe { Box::from_raw(self.contents.err) };
314 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::TxCreationKeys, crate::c_types::Secp256k1Error>> for CResult_TxCreationKeysErrorZ {
315 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::TxCreationKeys, crate::c_types::Secp256k1Error>) -> Self {
316 let contents = if o.result_ok {
317 let result = unsafe { o.contents.result };
318 unsafe { o.contents.result = std::ptr::null_mut() };
319 CResult_TxCreationKeysErrorZPtr { result }
321 let err = unsafe { o.contents.err };
322 unsafe { o.contents.err = std::ptr::null_mut(); }
323 CResult_TxCreationKeysErrorZPtr { err }
327 result_ok: o.result_ok,
333 pub enum COption_u32Z {
338 #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
339 if let Self::Some(_) = self { true } else { false }
341 #[allow(unused)] pub(crate) fn take(mut self) -> u32 {
342 if let Self::Some(v) = self { v } else { unreachable!() }
346 pub extern "C" fn COption_u32Z_some(o: u32) -> COption_u32Z {
347 COption_u32Z::Some(o)
350 pub extern "C" fn COption_u32Z_none() -> COption_u32Z {
354 pub extern "C" fn COption_u32Z_free(_res: COption_u32Z) { }
356 pub extern "C" fn COption_u32Z_clone(orig: &COption_u32Z) -> COption_u32Z { orig.clone() }
358 pub union CResult_HTLCOutputInCommitmentDecodeErrorZPtr {
359 pub result: *mut crate::ln::chan_utils::HTLCOutputInCommitment,
360 pub err: *mut crate::ln::msgs::DecodeError,
363 pub struct CResult_HTLCOutputInCommitmentDecodeErrorZ {
364 pub contents: CResult_HTLCOutputInCommitmentDecodeErrorZPtr,
368 pub extern "C" fn CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: crate::ln::chan_utils::HTLCOutputInCommitment) -> CResult_HTLCOutputInCommitmentDecodeErrorZ {
369 CResult_HTLCOutputInCommitmentDecodeErrorZ {
370 contents: CResult_HTLCOutputInCommitmentDecodeErrorZPtr {
371 result: Box::into_raw(Box::new(o)),
377 pub extern "C" fn CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_HTLCOutputInCommitmentDecodeErrorZ {
378 CResult_HTLCOutputInCommitmentDecodeErrorZ {
379 contents: CResult_HTLCOutputInCommitmentDecodeErrorZPtr {
380 err: Box::into_raw(Box::new(e)),
386 pub extern "C" fn CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: CResult_HTLCOutputInCommitmentDecodeErrorZ) { }
387 impl Drop for CResult_HTLCOutputInCommitmentDecodeErrorZ {
390 if unsafe { !(self.contents.result as *mut ()).is_null() } {
391 let _ = unsafe { Box::from_raw(self.contents.result) };
394 if unsafe { !(self.contents.err as *mut ()).is_null() } {
395 let _ = unsafe { Box::from_raw(self.contents.err) };
400 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::HTLCOutputInCommitment, crate::ln::msgs::DecodeError>> for CResult_HTLCOutputInCommitmentDecodeErrorZ {
401 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::HTLCOutputInCommitment, crate::ln::msgs::DecodeError>) -> Self {
402 let contents = if o.result_ok {
403 let result = unsafe { o.contents.result };
404 unsafe { o.contents.result = std::ptr::null_mut() };
405 CResult_HTLCOutputInCommitmentDecodeErrorZPtr { result }
407 let err = unsafe { o.contents.err };
408 unsafe { o.contents.err = std::ptr::null_mut(); }
409 CResult_HTLCOutputInCommitmentDecodeErrorZPtr { err }
413 result_ok: o.result_ok,
417 impl Clone for CResult_HTLCOutputInCommitmentDecodeErrorZ {
418 fn clone(&self) -> Self {
420 Self { result_ok: true, contents: CResult_HTLCOutputInCommitmentDecodeErrorZPtr {
421 result: Box::into_raw(Box::new(<crate::ln::chan_utils::HTLCOutputInCommitment>::clone(unsafe { &*self.contents.result })))
424 Self { result_ok: false, contents: CResult_HTLCOutputInCommitmentDecodeErrorZPtr {
425 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
431 pub extern "C" fn CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: &CResult_HTLCOutputInCommitmentDecodeErrorZ) -> CResult_HTLCOutputInCommitmentDecodeErrorZ { orig.clone() }
433 pub union CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
434 pub result: *mut crate::ln::chan_utils::CounterpartyChannelTransactionParameters,
435 pub err: *mut crate::ln::msgs::DecodeError,
438 pub struct CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
439 pub contents: CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr,
443 pub extern "C" fn CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: crate::ln::chan_utils::CounterpartyChannelTransactionParameters) -> CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
444 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
445 contents: CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
446 result: Box::into_raw(Box::new(o)),
452 pub extern "C" fn CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
453 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
454 contents: CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
455 err: Box::into_raw(Box::new(e)),
461 pub extern "C" fn CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: CResult_CounterpartyChannelTransactionParametersDecodeErrorZ) { }
462 impl Drop for CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
465 if unsafe { !(self.contents.result as *mut ()).is_null() } {
466 let _ = unsafe { Box::from_raw(self.contents.result) };
469 if unsafe { !(self.contents.err as *mut ()).is_null() } {
470 let _ = unsafe { Box::from_raw(self.contents.err) };
475 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::CounterpartyChannelTransactionParameters, crate::ln::msgs::DecodeError>> for CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
476 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::CounterpartyChannelTransactionParameters, crate::ln::msgs::DecodeError>) -> Self {
477 let contents = if o.result_ok {
478 let result = unsafe { o.contents.result };
479 unsafe { o.contents.result = std::ptr::null_mut() };
480 CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr { result }
482 let err = unsafe { o.contents.err };
483 unsafe { o.contents.err = std::ptr::null_mut(); }
484 CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr { err }
488 result_ok: o.result_ok,
492 impl Clone for CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
493 fn clone(&self) -> Self {
495 Self { result_ok: true, contents: CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
496 result: Box::into_raw(Box::new(<crate::ln::chan_utils::CounterpartyChannelTransactionParameters>::clone(unsafe { &*self.contents.result })))
499 Self { result_ok: false, contents: CResult_CounterpartyChannelTransactionParametersDecodeErrorZPtr {
500 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
506 pub extern "C" fn CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: &CResult_CounterpartyChannelTransactionParametersDecodeErrorZ) -> CResult_CounterpartyChannelTransactionParametersDecodeErrorZ { orig.clone() }
508 pub union CResult_ChannelTransactionParametersDecodeErrorZPtr {
509 pub result: *mut crate::ln::chan_utils::ChannelTransactionParameters,
510 pub err: *mut crate::ln::msgs::DecodeError,
513 pub struct CResult_ChannelTransactionParametersDecodeErrorZ {
514 pub contents: CResult_ChannelTransactionParametersDecodeErrorZPtr,
518 pub extern "C" fn CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: crate::ln::chan_utils::ChannelTransactionParameters) -> CResult_ChannelTransactionParametersDecodeErrorZ {
519 CResult_ChannelTransactionParametersDecodeErrorZ {
520 contents: CResult_ChannelTransactionParametersDecodeErrorZPtr {
521 result: Box::into_raw(Box::new(o)),
527 pub extern "C" fn CResult_ChannelTransactionParametersDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelTransactionParametersDecodeErrorZ {
528 CResult_ChannelTransactionParametersDecodeErrorZ {
529 contents: CResult_ChannelTransactionParametersDecodeErrorZPtr {
530 err: Box::into_raw(Box::new(e)),
536 pub extern "C" fn CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: CResult_ChannelTransactionParametersDecodeErrorZ) { }
537 impl Drop for CResult_ChannelTransactionParametersDecodeErrorZ {
540 if unsafe { !(self.contents.result as *mut ()).is_null() } {
541 let _ = unsafe { Box::from_raw(self.contents.result) };
544 if unsafe { !(self.contents.err as *mut ()).is_null() } {
545 let _ = unsafe { Box::from_raw(self.contents.err) };
550 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::ChannelTransactionParameters, crate::ln::msgs::DecodeError>> for CResult_ChannelTransactionParametersDecodeErrorZ {
551 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::ChannelTransactionParameters, crate::ln::msgs::DecodeError>) -> Self {
552 let contents = if o.result_ok {
553 let result = unsafe { o.contents.result };
554 unsafe { o.contents.result = std::ptr::null_mut() };
555 CResult_ChannelTransactionParametersDecodeErrorZPtr { result }
557 let err = unsafe { o.contents.err };
558 unsafe { o.contents.err = std::ptr::null_mut(); }
559 CResult_ChannelTransactionParametersDecodeErrorZPtr { err }
563 result_ok: o.result_ok,
567 impl Clone for CResult_ChannelTransactionParametersDecodeErrorZ {
568 fn clone(&self) -> Self {
570 Self { result_ok: true, contents: CResult_ChannelTransactionParametersDecodeErrorZPtr {
571 result: Box::into_raw(Box::new(<crate::ln::chan_utils::ChannelTransactionParameters>::clone(unsafe { &*self.contents.result })))
574 Self { result_ok: false, contents: CResult_ChannelTransactionParametersDecodeErrorZPtr {
575 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
581 pub extern "C" fn CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: &CResult_ChannelTransactionParametersDecodeErrorZ) -> CResult_ChannelTransactionParametersDecodeErrorZ { orig.clone() }
583 pub struct CVec_SignatureZ {
584 pub data: *mut crate::c_types::Signature,
587 impl CVec_SignatureZ {
588 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::Signature> {
589 if self.datalen == 0 { return Vec::new(); }
590 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
591 self.data = std::ptr::null_mut();
595 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::Signature] {
596 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
599 impl From<Vec<crate::c_types::Signature>> for CVec_SignatureZ {
600 fn from(v: Vec<crate::c_types::Signature>) -> Self {
601 let datalen = v.len();
602 let data = Box::into_raw(v.into_boxed_slice());
603 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
607 pub extern "C" fn CVec_SignatureZ_free(_res: CVec_SignatureZ) { }
608 impl Drop for CVec_SignatureZ {
610 if self.datalen == 0 { return; }
611 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
614 impl Clone for CVec_SignatureZ {
615 fn clone(&self) -> Self {
616 let mut res = Vec::new();
617 if self.datalen == 0 { return Self::from(res); }
618 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
623 pub union CResult_HolderCommitmentTransactionDecodeErrorZPtr {
624 pub result: *mut crate::ln::chan_utils::HolderCommitmentTransaction,
625 pub err: *mut crate::ln::msgs::DecodeError,
628 pub struct CResult_HolderCommitmentTransactionDecodeErrorZ {
629 pub contents: CResult_HolderCommitmentTransactionDecodeErrorZPtr,
633 pub extern "C" fn CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: crate::ln::chan_utils::HolderCommitmentTransaction) -> CResult_HolderCommitmentTransactionDecodeErrorZ {
634 CResult_HolderCommitmentTransactionDecodeErrorZ {
635 contents: CResult_HolderCommitmentTransactionDecodeErrorZPtr {
636 result: Box::into_raw(Box::new(o)),
642 pub extern "C" fn CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_HolderCommitmentTransactionDecodeErrorZ {
643 CResult_HolderCommitmentTransactionDecodeErrorZ {
644 contents: CResult_HolderCommitmentTransactionDecodeErrorZPtr {
645 err: Box::into_raw(Box::new(e)),
651 pub extern "C" fn CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: CResult_HolderCommitmentTransactionDecodeErrorZ) { }
652 impl Drop for CResult_HolderCommitmentTransactionDecodeErrorZ {
655 if unsafe { !(self.contents.result as *mut ()).is_null() } {
656 let _ = unsafe { Box::from_raw(self.contents.result) };
659 if unsafe { !(self.contents.err as *mut ()).is_null() } {
660 let _ = unsafe { Box::from_raw(self.contents.err) };
665 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::HolderCommitmentTransaction, crate::ln::msgs::DecodeError>> for CResult_HolderCommitmentTransactionDecodeErrorZ {
666 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::HolderCommitmentTransaction, crate::ln::msgs::DecodeError>) -> Self {
667 let contents = if o.result_ok {
668 let result = unsafe { o.contents.result };
669 unsafe { o.contents.result = std::ptr::null_mut() };
670 CResult_HolderCommitmentTransactionDecodeErrorZPtr { result }
672 let err = unsafe { o.contents.err };
673 unsafe { o.contents.err = std::ptr::null_mut(); }
674 CResult_HolderCommitmentTransactionDecodeErrorZPtr { err }
678 result_ok: o.result_ok,
682 impl Clone for CResult_HolderCommitmentTransactionDecodeErrorZ {
683 fn clone(&self) -> Self {
685 Self { result_ok: true, contents: CResult_HolderCommitmentTransactionDecodeErrorZPtr {
686 result: Box::into_raw(Box::new(<crate::ln::chan_utils::HolderCommitmentTransaction>::clone(unsafe { &*self.contents.result })))
689 Self { result_ok: false, contents: CResult_HolderCommitmentTransactionDecodeErrorZPtr {
690 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
696 pub extern "C" fn CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: &CResult_HolderCommitmentTransactionDecodeErrorZ) -> CResult_HolderCommitmentTransactionDecodeErrorZ { orig.clone() }
698 pub union CResult_BuiltCommitmentTransactionDecodeErrorZPtr {
699 pub result: *mut crate::ln::chan_utils::BuiltCommitmentTransaction,
700 pub err: *mut crate::ln::msgs::DecodeError,
703 pub struct CResult_BuiltCommitmentTransactionDecodeErrorZ {
704 pub contents: CResult_BuiltCommitmentTransactionDecodeErrorZPtr,
708 pub extern "C" fn CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: crate::ln::chan_utils::BuiltCommitmentTransaction) -> CResult_BuiltCommitmentTransactionDecodeErrorZ {
709 CResult_BuiltCommitmentTransactionDecodeErrorZ {
710 contents: CResult_BuiltCommitmentTransactionDecodeErrorZPtr {
711 result: Box::into_raw(Box::new(o)),
717 pub extern "C" fn CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_BuiltCommitmentTransactionDecodeErrorZ {
718 CResult_BuiltCommitmentTransactionDecodeErrorZ {
719 contents: CResult_BuiltCommitmentTransactionDecodeErrorZPtr {
720 err: Box::into_raw(Box::new(e)),
726 pub extern "C" fn CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: CResult_BuiltCommitmentTransactionDecodeErrorZ) { }
727 impl Drop for CResult_BuiltCommitmentTransactionDecodeErrorZ {
730 if unsafe { !(self.contents.result as *mut ()).is_null() } {
731 let _ = unsafe { Box::from_raw(self.contents.result) };
734 if unsafe { !(self.contents.err as *mut ()).is_null() } {
735 let _ = unsafe { Box::from_raw(self.contents.err) };
740 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::BuiltCommitmentTransaction, crate::ln::msgs::DecodeError>> for CResult_BuiltCommitmentTransactionDecodeErrorZ {
741 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::BuiltCommitmentTransaction, crate::ln::msgs::DecodeError>) -> Self {
742 let contents = if o.result_ok {
743 let result = unsafe { o.contents.result };
744 unsafe { o.contents.result = std::ptr::null_mut() };
745 CResult_BuiltCommitmentTransactionDecodeErrorZPtr { result }
747 let err = unsafe { o.contents.err };
748 unsafe { o.contents.err = std::ptr::null_mut(); }
749 CResult_BuiltCommitmentTransactionDecodeErrorZPtr { err }
753 result_ok: o.result_ok,
757 impl Clone for CResult_BuiltCommitmentTransactionDecodeErrorZ {
758 fn clone(&self) -> Self {
760 Self { result_ok: true, contents: CResult_BuiltCommitmentTransactionDecodeErrorZPtr {
761 result: Box::into_raw(Box::new(<crate::ln::chan_utils::BuiltCommitmentTransaction>::clone(unsafe { &*self.contents.result })))
764 Self { result_ok: false, contents: CResult_BuiltCommitmentTransactionDecodeErrorZPtr {
765 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
771 pub extern "C" fn CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: &CResult_BuiltCommitmentTransactionDecodeErrorZ) -> CResult_BuiltCommitmentTransactionDecodeErrorZ { orig.clone() }
773 pub union CResult_CommitmentTransactionDecodeErrorZPtr {
774 pub result: *mut crate::ln::chan_utils::CommitmentTransaction,
775 pub err: *mut crate::ln::msgs::DecodeError,
778 pub struct CResult_CommitmentTransactionDecodeErrorZ {
779 pub contents: CResult_CommitmentTransactionDecodeErrorZPtr,
783 pub extern "C" fn CResult_CommitmentTransactionDecodeErrorZ_ok(o: crate::ln::chan_utils::CommitmentTransaction) -> CResult_CommitmentTransactionDecodeErrorZ {
784 CResult_CommitmentTransactionDecodeErrorZ {
785 contents: CResult_CommitmentTransactionDecodeErrorZPtr {
786 result: Box::into_raw(Box::new(o)),
792 pub extern "C" fn CResult_CommitmentTransactionDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_CommitmentTransactionDecodeErrorZ {
793 CResult_CommitmentTransactionDecodeErrorZ {
794 contents: CResult_CommitmentTransactionDecodeErrorZPtr {
795 err: Box::into_raw(Box::new(e)),
801 pub extern "C" fn CResult_CommitmentTransactionDecodeErrorZ_free(_res: CResult_CommitmentTransactionDecodeErrorZ) { }
802 impl Drop for CResult_CommitmentTransactionDecodeErrorZ {
805 if unsafe { !(self.contents.result as *mut ()).is_null() } {
806 let _ = unsafe { Box::from_raw(self.contents.result) };
809 if unsafe { !(self.contents.err as *mut ()).is_null() } {
810 let _ = unsafe { Box::from_raw(self.contents.err) };
815 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::CommitmentTransaction, crate::ln::msgs::DecodeError>> for CResult_CommitmentTransactionDecodeErrorZ {
816 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::CommitmentTransaction, crate::ln::msgs::DecodeError>) -> Self {
817 let contents = if o.result_ok {
818 let result = unsafe { o.contents.result };
819 unsafe { o.contents.result = std::ptr::null_mut() };
820 CResult_CommitmentTransactionDecodeErrorZPtr { result }
822 let err = unsafe { o.contents.err };
823 unsafe { o.contents.err = std::ptr::null_mut(); }
824 CResult_CommitmentTransactionDecodeErrorZPtr { err }
828 result_ok: o.result_ok,
832 impl Clone for CResult_CommitmentTransactionDecodeErrorZ {
833 fn clone(&self) -> Self {
835 Self { result_ok: true, contents: CResult_CommitmentTransactionDecodeErrorZPtr {
836 result: Box::into_raw(Box::new(<crate::ln::chan_utils::CommitmentTransaction>::clone(unsafe { &*self.contents.result })))
839 Self { result_ok: false, contents: CResult_CommitmentTransactionDecodeErrorZPtr {
840 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
846 pub extern "C" fn CResult_CommitmentTransactionDecodeErrorZ_clone(orig: &CResult_CommitmentTransactionDecodeErrorZ) -> CResult_CommitmentTransactionDecodeErrorZ { orig.clone() }
848 pub union CResult_TrustedCommitmentTransactionNoneZPtr {
849 pub result: *mut crate::ln::chan_utils::TrustedCommitmentTransaction,
850 /// Note that this value is always NULL, as there are no contents in the Err variant
851 pub err: *mut std::ffi::c_void,
854 pub struct CResult_TrustedCommitmentTransactionNoneZ {
855 pub contents: CResult_TrustedCommitmentTransactionNoneZPtr,
859 pub extern "C" fn CResult_TrustedCommitmentTransactionNoneZ_ok(o: crate::ln::chan_utils::TrustedCommitmentTransaction) -> CResult_TrustedCommitmentTransactionNoneZ {
860 CResult_TrustedCommitmentTransactionNoneZ {
861 contents: CResult_TrustedCommitmentTransactionNoneZPtr {
862 result: Box::into_raw(Box::new(o)),
868 pub extern "C" fn CResult_TrustedCommitmentTransactionNoneZ_err() -> CResult_TrustedCommitmentTransactionNoneZ {
869 CResult_TrustedCommitmentTransactionNoneZ {
870 contents: CResult_TrustedCommitmentTransactionNoneZPtr {
871 err: std::ptr::null_mut(),
877 pub extern "C" fn CResult_TrustedCommitmentTransactionNoneZ_free(_res: CResult_TrustedCommitmentTransactionNoneZ) { }
878 impl Drop for CResult_TrustedCommitmentTransactionNoneZ {
881 if unsafe { !(self.contents.result as *mut ()).is_null() } {
882 let _ = unsafe { Box::from_raw(self.contents.result) };
888 impl From<crate::c_types::CResultTempl<crate::ln::chan_utils::TrustedCommitmentTransaction, u8>> for CResult_TrustedCommitmentTransactionNoneZ {
889 fn from(mut o: crate::c_types::CResultTempl<crate::ln::chan_utils::TrustedCommitmentTransaction, u8>) -> Self {
890 let contents = if o.result_ok {
891 let result = unsafe { o.contents.result };
892 unsafe { o.contents.result = std::ptr::null_mut() };
893 CResult_TrustedCommitmentTransactionNoneZPtr { result }
895 let _ = unsafe { Box::from_raw(o.contents.err) };
896 o.contents.err = std::ptr::null_mut();
897 CResult_TrustedCommitmentTransactionNoneZPtr { err: std::ptr::null_mut() }
901 result_ok: o.result_ok,
906 pub union CResult_CVec_SignatureZNoneZPtr {
907 pub result: *mut crate::c_types::derived::CVec_SignatureZ,
908 /// Note that this value is always NULL, as there are no contents in the Err variant
909 pub err: *mut std::ffi::c_void,
912 pub struct CResult_CVec_SignatureZNoneZ {
913 pub contents: CResult_CVec_SignatureZNoneZPtr,
917 pub extern "C" fn CResult_CVec_SignatureZNoneZ_ok(o: crate::c_types::derived::CVec_SignatureZ) -> CResult_CVec_SignatureZNoneZ {
918 CResult_CVec_SignatureZNoneZ {
919 contents: CResult_CVec_SignatureZNoneZPtr {
920 result: Box::into_raw(Box::new(o)),
926 pub extern "C" fn CResult_CVec_SignatureZNoneZ_err() -> CResult_CVec_SignatureZNoneZ {
927 CResult_CVec_SignatureZNoneZ {
928 contents: CResult_CVec_SignatureZNoneZPtr {
929 err: std::ptr::null_mut(),
935 pub extern "C" fn CResult_CVec_SignatureZNoneZ_free(_res: CResult_CVec_SignatureZNoneZ) { }
936 impl Drop for CResult_CVec_SignatureZNoneZ {
939 if unsafe { !(self.contents.result as *mut ()).is_null() } {
940 let _ = unsafe { Box::from_raw(self.contents.result) };
946 impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_SignatureZ, u8>> for CResult_CVec_SignatureZNoneZ {
947 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_SignatureZ, u8>) -> Self {
948 let contents = if o.result_ok {
949 let result = unsafe { o.contents.result };
950 unsafe { o.contents.result = std::ptr::null_mut() };
951 CResult_CVec_SignatureZNoneZPtr { result }
953 let _ = unsafe { Box::from_raw(o.contents.err) };
954 o.contents.err = std::ptr::null_mut();
955 CResult_CVec_SignatureZNoneZPtr { err: std::ptr::null_mut() }
959 result_ok: o.result_ok,
963 impl Clone for CResult_CVec_SignatureZNoneZ {
964 fn clone(&self) -> Self {
966 Self { result_ok: true, contents: CResult_CVec_SignatureZNoneZPtr {
967 result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_SignatureZ>::clone(unsafe { &*self.contents.result })))
970 Self { result_ok: false, contents: CResult_CVec_SignatureZNoneZPtr {
971 err: std::ptr::null_mut()
977 pub extern "C" fn CResult_CVec_SignatureZNoneZ_clone(orig: &CResult_CVec_SignatureZNoneZ) -> CResult_CVec_SignatureZNoneZ { orig.clone() }
979 pub struct CVec_MessageSendEventZ {
980 pub data: *mut crate::util::events::MessageSendEvent,
983 impl CVec_MessageSendEventZ {
984 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::util::events::MessageSendEvent> {
985 if self.datalen == 0 { return Vec::new(); }
986 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
987 self.data = std::ptr::null_mut();
991 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::util::events::MessageSendEvent] {
992 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
995 impl From<Vec<crate::util::events::MessageSendEvent>> for CVec_MessageSendEventZ {
996 fn from(v: Vec<crate::util::events::MessageSendEvent>) -> Self {
997 let datalen = v.len();
998 let data = Box::into_raw(v.into_boxed_slice());
999 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
1003 pub extern "C" fn CVec_MessageSendEventZ_free(_res: CVec_MessageSendEventZ) { }
1004 impl Drop for CVec_MessageSendEventZ {
1005 fn drop(&mut self) {
1006 if self.datalen == 0 { return; }
1007 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
1010 impl Clone for CVec_MessageSendEventZ {
1011 fn clone(&self) -> Self {
1012 let mut res = Vec::new();
1013 if self.datalen == 0 { return Self::from(res); }
1014 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
1019 pub union CResult_boolLightningErrorZPtr {
1020 pub result: *mut bool,
1021 pub err: *mut crate::ln::msgs::LightningError,
1024 pub struct CResult_boolLightningErrorZ {
1025 pub contents: CResult_boolLightningErrorZPtr,
1026 pub result_ok: bool,
1029 pub extern "C" fn CResult_boolLightningErrorZ_ok(o: bool) -> CResult_boolLightningErrorZ {
1030 CResult_boolLightningErrorZ {
1031 contents: CResult_boolLightningErrorZPtr {
1032 result: Box::into_raw(Box::new(o)),
1038 pub extern "C" fn CResult_boolLightningErrorZ_err(e: crate::ln::msgs::LightningError) -> CResult_boolLightningErrorZ {
1039 CResult_boolLightningErrorZ {
1040 contents: CResult_boolLightningErrorZPtr {
1041 err: Box::into_raw(Box::new(e)),
1047 pub extern "C" fn CResult_boolLightningErrorZ_free(_res: CResult_boolLightningErrorZ) { }
1048 impl Drop for CResult_boolLightningErrorZ {
1049 fn drop(&mut self) {
1051 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1052 let _ = unsafe { Box::from_raw(self.contents.result) };
1055 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1056 let _ = unsafe { Box::from_raw(self.contents.err) };
1061 impl From<crate::c_types::CResultTempl<bool, crate::ln::msgs::LightningError>> for CResult_boolLightningErrorZ {
1062 fn from(mut o: crate::c_types::CResultTempl<bool, crate::ln::msgs::LightningError>) -> Self {
1063 let contents = if o.result_ok {
1064 let result = unsafe { o.contents.result };
1065 unsafe { o.contents.result = std::ptr::null_mut() };
1066 CResult_boolLightningErrorZPtr { result }
1068 let err = unsafe { o.contents.err };
1069 unsafe { o.contents.err = std::ptr::null_mut(); }
1070 CResult_boolLightningErrorZPtr { err }
1074 result_ok: o.result_ok,
1078 impl Clone for CResult_boolLightningErrorZ {
1079 fn clone(&self) -> Self {
1081 Self { result_ok: true, contents: CResult_boolLightningErrorZPtr {
1082 result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
1085 Self { result_ok: false, contents: CResult_boolLightningErrorZPtr {
1086 err: Box::into_raw(Box::new(<crate::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
1092 pub extern "C" fn CResult_boolLightningErrorZ_clone(orig: &CResult_boolLightningErrorZ) -> CResult_boolLightningErrorZ { orig.clone() }
1094 pub struct C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1095 pub a: crate::ln::msgs::ChannelAnnouncement,
1096 pub b: crate::ln::msgs::ChannelUpdate,
1097 pub c: crate::ln::msgs::ChannelUpdate,
1099 impl From<(crate::ln::msgs::ChannelAnnouncement, crate::ln::msgs::ChannelUpdate, crate::ln::msgs::ChannelUpdate)> for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1100 fn from (tup: (crate::ln::msgs::ChannelAnnouncement, crate::ln::msgs::ChannelUpdate, crate::ln::msgs::ChannelUpdate)) -> Self {
1108 impl C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1109 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::ln::msgs::ChannelAnnouncement, crate::ln::msgs::ChannelUpdate, crate::ln::msgs::ChannelUpdate) {
1110 (self.a, self.b, self.c)
1113 impl Clone for C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1114 fn clone(&self) -> Self {
1123 pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: &C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { orig.clone() }
1125 pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: crate::ln::msgs::ChannelAnnouncement, b: crate::ln::msgs::ChannelUpdate, c: crate::ln::msgs::ChannelUpdate) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1126 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { a, b, c, }
1130 pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) { }
1132 pub struct CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1133 pub data: *mut crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ,
1136 impl CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1137 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ> {
1138 if self.datalen == 0 { return Vec::new(); }
1139 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
1140 self.data = std::ptr::null_mut();
1144 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ] {
1145 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
1148 impl From<Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>> for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1149 fn from(v: Vec<crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ>) -> Self {
1150 let datalen = v.len();
1151 let data = Box::into_raw(v.into_boxed_slice());
1152 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
1156 pub extern "C" fn CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ) { }
1157 impl Drop for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1158 fn drop(&mut self) {
1159 if self.datalen == 0 { return; }
1160 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
1163 impl Clone for CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1164 fn clone(&self) -> Self {
1165 let mut res = Vec::new();
1166 if self.datalen == 0 { return Self::from(res); }
1167 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
1172 pub struct CVec_NodeAnnouncementZ {
1173 pub data: *mut crate::ln::msgs::NodeAnnouncement,
1176 impl CVec_NodeAnnouncementZ {
1177 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::NodeAnnouncement> {
1178 if self.datalen == 0 { return Vec::new(); }
1179 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
1180 self.data = std::ptr::null_mut();
1184 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::NodeAnnouncement] {
1185 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
1188 impl From<Vec<crate::ln::msgs::NodeAnnouncement>> for CVec_NodeAnnouncementZ {
1189 fn from(v: Vec<crate::ln::msgs::NodeAnnouncement>) -> Self {
1190 let datalen = v.len();
1191 let data = Box::into_raw(v.into_boxed_slice());
1192 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
1196 pub extern "C" fn CVec_NodeAnnouncementZ_free(_res: CVec_NodeAnnouncementZ) { }
1197 impl Drop for CVec_NodeAnnouncementZ {
1198 fn drop(&mut self) {
1199 if self.datalen == 0 { return; }
1200 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
1203 impl Clone for CVec_NodeAnnouncementZ {
1204 fn clone(&self) -> Self {
1205 let mut res = Vec::new();
1206 if self.datalen == 0 { return Self::from(res); }
1207 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
1212 pub union CResult_NoneLightningErrorZPtr {
1213 /// Note that this value is always NULL, as there are no contents in the OK variant
1214 pub result: *mut std::ffi::c_void,
1215 pub err: *mut crate::ln::msgs::LightningError,
1218 pub struct CResult_NoneLightningErrorZ {
1219 pub contents: CResult_NoneLightningErrorZPtr,
1220 pub result_ok: bool,
1223 pub extern "C" fn CResult_NoneLightningErrorZ_ok() -> CResult_NoneLightningErrorZ {
1224 CResult_NoneLightningErrorZ {
1225 contents: CResult_NoneLightningErrorZPtr {
1226 result: std::ptr::null_mut(),
1232 pub extern "C" fn CResult_NoneLightningErrorZ_err(e: crate::ln::msgs::LightningError) -> CResult_NoneLightningErrorZ {
1233 CResult_NoneLightningErrorZ {
1234 contents: CResult_NoneLightningErrorZPtr {
1235 err: Box::into_raw(Box::new(e)),
1241 pub extern "C" fn CResult_NoneLightningErrorZ_free(_res: CResult_NoneLightningErrorZ) { }
1242 impl Drop for CResult_NoneLightningErrorZ {
1243 fn drop(&mut self) {
1246 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1247 let _ = unsafe { Box::from_raw(self.contents.err) };
1252 impl From<crate::c_types::CResultTempl<u8, crate::ln::msgs::LightningError>> for CResult_NoneLightningErrorZ {
1253 fn from(mut o: crate::c_types::CResultTempl<u8, crate::ln::msgs::LightningError>) -> Self {
1254 let contents = if o.result_ok {
1255 let _ = unsafe { Box::from_raw(o.contents.result) };
1256 o.contents.result = std::ptr::null_mut();
1257 CResult_NoneLightningErrorZPtr { result: std::ptr::null_mut() }
1259 let err = unsafe { o.contents.err };
1260 unsafe { o.contents.err = std::ptr::null_mut(); }
1261 CResult_NoneLightningErrorZPtr { err }
1265 result_ok: o.result_ok,
1269 impl Clone for CResult_NoneLightningErrorZ {
1270 fn clone(&self) -> Self {
1272 Self { result_ok: true, contents: CResult_NoneLightningErrorZPtr {
1273 result: std::ptr::null_mut()
1276 Self { result_ok: false, contents: CResult_NoneLightningErrorZPtr {
1277 err: Box::into_raw(Box::new(<crate::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
1283 pub extern "C" fn CResult_NoneLightningErrorZ_clone(orig: &CResult_NoneLightningErrorZ) -> CResult_NoneLightningErrorZ { orig.clone() }
1285 pub struct CVec_PublicKeyZ {
1286 pub data: *mut crate::c_types::PublicKey,
1289 impl CVec_PublicKeyZ {
1290 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::PublicKey> {
1291 if self.datalen == 0 { return Vec::new(); }
1292 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
1293 self.data = std::ptr::null_mut();
1297 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::PublicKey] {
1298 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
1301 impl From<Vec<crate::c_types::PublicKey>> for CVec_PublicKeyZ {
1302 fn from(v: Vec<crate::c_types::PublicKey>) -> Self {
1303 let datalen = v.len();
1304 let data = Box::into_raw(v.into_boxed_slice());
1305 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
1309 pub extern "C" fn CVec_PublicKeyZ_free(_res: CVec_PublicKeyZ) { }
1310 impl Drop for CVec_PublicKeyZ {
1311 fn drop(&mut self) {
1312 if self.datalen == 0 { return; }
1313 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
1317 pub struct CVec_u8Z {
1322 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u8> {
1323 if self.datalen == 0 { return Vec::new(); }
1324 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
1325 self.data = std::ptr::null_mut();
1329 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u8] {
1330 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
1333 impl From<Vec<u8>> for CVec_u8Z {
1334 fn from(v: Vec<u8>) -> Self {
1335 let datalen = v.len();
1336 let data = Box::into_raw(v.into_boxed_slice());
1337 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
1341 pub extern "C" fn CVec_u8Z_free(_res: CVec_u8Z) { }
1342 impl Drop for CVec_u8Z {
1343 fn drop(&mut self) {
1344 if self.datalen == 0 { return; }
1345 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
1348 impl Clone for CVec_u8Z {
1349 fn clone(&self) -> Self {
1350 let mut res = Vec::new();
1351 if self.datalen == 0 { return Self::from(res); }
1352 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
1357 pub union CResult_CVec_u8ZPeerHandleErrorZPtr {
1358 pub result: *mut crate::c_types::derived::CVec_u8Z,
1359 pub err: *mut crate::ln::peer_handler::PeerHandleError,
1362 pub struct CResult_CVec_u8ZPeerHandleErrorZ {
1363 pub contents: CResult_CVec_u8ZPeerHandleErrorZPtr,
1364 pub result_ok: bool,
1367 pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_ok(o: crate::c_types::derived::CVec_u8Z) -> CResult_CVec_u8ZPeerHandleErrorZ {
1368 CResult_CVec_u8ZPeerHandleErrorZ {
1369 contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
1370 result: Box::into_raw(Box::new(o)),
1376 pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_err(e: crate::ln::peer_handler::PeerHandleError) -> CResult_CVec_u8ZPeerHandleErrorZ {
1377 CResult_CVec_u8ZPeerHandleErrorZ {
1378 contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
1379 err: Box::into_raw(Box::new(e)),
1385 pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_free(_res: CResult_CVec_u8ZPeerHandleErrorZ) { }
1386 impl Drop for CResult_CVec_u8ZPeerHandleErrorZ {
1387 fn drop(&mut self) {
1389 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1390 let _ = unsafe { Box::from_raw(self.contents.result) };
1393 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1394 let _ = unsafe { Box::from_raw(self.contents.err) };
1399 impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::ln::peer_handler::PeerHandleError>> for CResult_CVec_u8ZPeerHandleErrorZ {
1400 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_u8Z, crate::ln::peer_handler::PeerHandleError>) -> Self {
1401 let contents = if o.result_ok {
1402 let result = unsafe { o.contents.result };
1403 unsafe { o.contents.result = std::ptr::null_mut() };
1404 CResult_CVec_u8ZPeerHandleErrorZPtr { result }
1406 let err = unsafe { o.contents.err };
1407 unsafe { o.contents.err = std::ptr::null_mut(); }
1408 CResult_CVec_u8ZPeerHandleErrorZPtr { err }
1412 result_ok: o.result_ok,
1416 impl Clone for CResult_CVec_u8ZPeerHandleErrorZ {
1417 fn clone(&self) -> Self {
1419 Self { result_ok: true, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
1420 result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_u8Z>::clone(unsafe { &*self.contents.result })))
1423 Self { result_ok: false, contents: CResult_CVec_u8ZPeerHandleErrorZPtr {
1424 err: Box::into_raw(Box::new(<crate::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
1430 pub extern "C" fn CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: &CResult_CVec_u8ZPeerHandleErrorZ) -> CResult_CVec_u8ZPeerHandleErrorZ { orig.clone() }
1432 pub union CResult_NonePeerHandleErrorZPtr {
1433 /// Note that this value is always NULL, as there are no contents in the OK variant
1434 pub result: *mut std::ffi::c_void,
1435 pub err: *mut crate::ln::peer_handler::PeerHandleError,
1438 pub struct CResult_NonePeerHandleErrorZ {
1439 pub contents: CResult_NonePeerHandleErrorZPtr,
1440 pub result_ok: bool,
1443 pub extern "C" fn CResult_NonePeerHandleErrorZ_ok() -> CResult_NonePeerHandleErrorZ {
1444 CResult_NonePeerHandleErrorZ {
1445 contents: CResult_NonePeerHandleErrorZPtr {
1446 result: std::ptr::null_mut(),
1452 pub extern "C" fn CResult_NonePeerHandleErrorZ_err(e: crate::ln::peer_handler::PeerHandleError) -> CResult_NonePeerHandleErrorZ {
1453 CResult_NonePeerHandleErrorZ {
1454 contents: CResult_NonePeerHandleErrorZPtr {
1455 err: Box::into_raw(Box::new(e)),
1461 pub extern "C" fn CResult_NonePeerHandleErrorZ_free(_res: CResult_NonePeerHandleErrorZ) { }
1462 impl Drop for CResult_NonePeerHandleErrorZ {
1463 fn drop(&mut self) {
1466 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1467 let _ = unsafe { Box::from_raw(self.contents.err) };
1472 impl From<crate::c_types::CResultTempl<u8, crate::ln::peer_handler::PeerHandleError>> for CResult_NonePeerHandleErrorZ {
1473 fn from(mut o: crate::c_types::CResultTempl<u8, crate::ln::peer_handler::PeerHandleError>) -> Self {
1474 let contents = if o.result_ok {
1475 let _ = unsafe { Box::from_raw(o.contents.result) };
1476 o.contents.result = std::ptr::null_mut();
1477 CResult_NonePeerHandleErrorZPtr { result: std::ptr::null_mut() }
1479 let err = unsafe { o.contents.err };
1480 unsafe { o.contents.err = std::ptr::null_mut(); }
1481 CResult_NonePeerHandleErrorZPtr { err }
1485 result_ok: o.result_ok,
1489 impl Clone for CResult_NonePeerHandleErrorZ {
1490 fn clone(&self) -> Self {
1492 Self { result_ok: true, contents: CResult_NonePeerHandleErrorZPtr {
1493 result: std::ptr::null_mut()
1496 Self { result_ok: false, contents: CResult_NonePeerHandleErrorZPtr {
1497 err: Box::into_raw(Box::new(<crate::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
1503 pub extern "C" fn CResult_NonePeerHandleErrorZ_clone(orig: &CResult_NonePeerHandleErrorZ) -> CResult_NonePeerHandleErrorZ { orig.clone() }
1505 pub union CResult_boolPeerHandleErrorZPtr {
1506 pub result: *mut bool,
1507 pub err: *mut crate::ln::peer_handler::PeerHandleError,
1510 pub struct CResult_boolPeerHandleErrorZ {
1511 pub contents: CResult_boolPeerHandleErrorZPtr,
1512 pub result_ok: bool,
1515 pub extern "C" fn CResult_boolPeerHandleErrorZ_ok(o: bool) -> CResult_boolPeerHandleErrorZ {
1516 CResult_boolPeerHandleErrorZ {
1517 contents: CResult_boolPeerHandleErrorZPtr {
1518 result: Box::into_raw(Box::new(o)),
1524 pub extern "C" fn CResult_boolPeerHandleErrorZ_err(e: crate::ln::peer_handler::PeerHandleError) -> CResult_boolPeerHandleErrorZ {
1525 CResult_boolPeerHandleErrorZ {
1526 contents: CResult_boolPeerHandleErrorZPtr {
1527 err: Box::into_raw(Box::new(e)),
1533 pub extern "C" fn CResult_boolPeerHandleErrorZ_free(_res: CResult_boolPeerHandleErrorZ) { }
1534 impl Drop for CResult_boolPeerHandleErrorZ {
1535 fn drop(&mut self) {
1537 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1538 let _ = unsafe { Box::from_raw(self.contents.result) };
1541 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1542 let _ = unsafe { Box::from_raw(self.contents.err) };
1547 impl From<crate::c_types::CResultTempl<bool, crate::ln::peer_handler::PeerHandleError>> for CResult_boolPeerHandleErrorZ {
1548 fn from(mut o: crate::c_types::CResultTempl<bool, crate::ln::peer_handler::PeerHandleError>) -> Self {
1549 let contents = if o.result_ok {
1550 let result = unsafe { o.contents.result };
1551 unsafe { o.contents.result = std::ptr::null_mut() };
1552 CResult_boolPeerHandleErrorZPtr { result }
1554 let err = unsafe { o.contents.err };
1555 unsafe { o.contents.err = std::ptr::null_mut(); }
1556 CResult_boolPeerHandleErrorZPtr { err }
1560 result_ok: o.result_ok,
1564 impl Clone for CResult_boolPeerHandleErrorZ {
1565 fn clone(&self) -> Self {
1567 Self { result_ok: true, contents: CResult_boolPeerHandleErrorZPtr {
1568 result: Box::into_raw(Box::new(<bool>::clone(unsafe { &*self.contents.result })))
1571 Self { result_ok: false, contents: CResult_boolPeerHandleErrorZPtr {
1572 err: Box::into_raw(Box::new(<crate::ln::peer_handler::PeerHandleError>::clone(unsafe { &*self.contents.err })))
1578 pub extern "C" fn CResult_boolPeerHandleErrorZ_clone(orig: &CResult_boolPeerHandleErrorZ) -> CResult_boolPeerHandleErrorZ { orig.clone() }
1580 pub union CResult_InitFeaturesDecodeErrorZPtr {
1581 pub result: *mut crate::ln::features::InitFeatures,
1582 pub err: *mut crate::ln::msgs::DecodeError,
1585 pub struct CResult_InitFeaturesDecodeErrorZ {
1586 pub contents: CResult_InitFeaturesDecodeErrorZPtr,
1587 pub result_ok: bool,
1590 pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_ok(o: crate::ln::features::InitFeatures) -> CResult_InitFeaturesDecodeErrorZ {
1591 CResult_InitFeaturesDecodeErrorZ {
1592 contents: CResult_InitFeaturesDecodeErrorZPtr {
1593 result: Box::into_raw(Box::new(o)),
1599 pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_InitFeaturesDecodeErrorZ {
1600 CResult_InitFeaturesDecodeErrorZ {
1601 contents: CResult_InitFeaturesDecodeErrorZPtr {
1602 err: Box::into_raw(Box::new(e)),
1608 pub extern "C" fn CResult_InitFeaturesDecodeErrorZ_free(_res: CResult_InitFeaturesDecodeErrorZ) { }
1609 impl Drop for CResult_InitFeaturesDecodeErrorZ {
1610 fn drop(&mut self) {
1612 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1613 let _ = unsafe { Box::from_raw(self.contents.result) };
1616 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1617 let _ = unsafe { Box::from_raw(self.contents.err) };
1622 impl From<crate::c_types::CResultTempl<crate::ln::features::InitFeatures, crate::ln::msgs::DecodeError>> for CResult_InitFeaturesDecodeErrorZ {
1623 fn from(mut o: crate::c_types::CResultTempl<crate::ln::features::InitFeatures, crate::ln::msgs::DecodeError>) -> Self {
1624 let contents = if o.result_ok {
1625 let result = unsafe { o.contents.result };
1626 unsafe { o.contents.result = std::ptr::null_mut() };
1627 CResult_InitFeaturesDecodeErrorZPtr { result }
1629 let err = unsafe { o.contents.err };
1630 unsafe { o.contents.err = std::ptr::null_mut(); }
1631 CResult_InitFeaturesDecodeErrorZPtr { err }
1635 result_ok: o.result_ok,
1640 pub union CResult_NodeFeaturesDecodeErrorZPtr {
1641 pub result: *mut crate::ln::features::NodeFeatures,
1642 pub err: *mut crate::ln::msgs::DecodeError,
1645 pub struct CResult_NodeFeaturesDecodeErrorZ {
1646 pub contents: CResult_NodeFeaturesDecodeErrorZPtr,
1647 pub result_ok: bool,
1650 pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_ok(o: crate::ln::features::NodeFeatures) -> CResult_NodeFeaturesDecodeErrorZ {
1651 CResult_NodeFeaturesDecodeErrorZ {
1652 contents: CResult_NodeFeaturesDecodeErrorZPtr {
1653 result: Box::into_raw(Box::new(o)),
1659 pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_NodeFeaturesDecodeErrorZ {
1660 CResult_NodeFeaturesDecodeErrorZ {
1661 contents: CResult_NodeFeaturesDecodeErrorZPtr {
1662 err: Box::into_raw(Box::new(e)),
1668 pub extern "C" fn CResult_NodeFeaturesDecodeErrorZ_free(_res: CResult_NodeFeaturesDecodeErrorZ) { }
1669 impl Drop for CResult_NodeFeaturesDecodeErrorZ {
1670 fn drop(&mut self) {
1672 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1673 let _ = unsafe { Box::from_raw(self.contents.result) };
1676 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1677 let _ = unsafe { Box::from_raw(self.contents.err) };
1682 impl From<crate::c_types::CResultTempl<crate::ln::features::NodeFeatures, crate::ln::msgs::DecodeError>> for CResult_NodeFeaturesDecodeErrorZ {
1683 fn from(mut o: crate::c_types::CResultTempl<crate::ln::features::NodeFeatures, crate::ln::msgs::DecodeError>) -> Self {
1684 let contents = if o.result_ok {
1685 let result = unsafe { o.contents.result };
1686 unsafe { o.contents.result = std::ptr::null_mut() };
1687 CResult_NodeFeaturesDecodeErrorZPtr { result }
1689 let err = unsafe { o.contents.err };
1690 unsafe { o.contents.err = std::ptr::null_mut(); }
1691 CResult_NodeFeaturesDecodeErrorZPtr { err }
1695 result_ok: o.result_ok,
1700 pub union CResult_ChannelFeaturesDecodeErrorZPtr {
1701 pub result: *mut crate::ln::features::ChannelFeatures,
1702 pub err: *mut crate::ln::msgs::DecodeError,
1705 pub struct CResult_ChannelFeaturesDecodeErrorZ {
1706 pub contents: CResult_ChannelFeaturesDecodeErrorZPtr,
1707 pub result_ok: bool,
1710 pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_ok(o: crate::ln::features::ChannelFeatures) -> CResult_ChannelFeaturesDecodeErrorZ {
1711 CResult_ChannelFeaturesDecodeErrorZ {
1712 contents: CResult_ChannelFeaturesDecodeErrorZPtr {
1713 result: Box::into_raw(Box::new(o)),
1719 pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelFeaturesDecodeErrorZ {
1720 CResult_ChannelFeaturesDecodeErrorZ {
1721 contents: CResult_ChannelFeaturesDecodeErrorZPtr {
1722 err: Box::into_raw(Box::new(e)),
1728 pub extern "C" fn CResult_ChannelFeaturesDecodeErrorZ_free(_res: CResult_ChannelFeaturesDecodeErrorZ) { }
1729 impl Drop for CResult_ChannelFeaturesDecodeErrorZ {
1730 fn drop(&mut self) {
1732 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1733 let _ = unsafe { Box::from_raw(self.contents.result) };
1736 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1737 let _ = unsafe { Box::from_raw(self.contents.err) };
1742 impl From<crate::c_types::CResultTempl<crate::ln::features::ChannelFeatures, crate::ln::msgs::DecodeError>> for CResult_ChannelFeaturesDecodeErrorZ {
1743 fn from(mut o: crate::c_types::CResultTempl<crate::ln::features::ChannelFeatures, crate::ln::msgs::DecodeError>) -> Self {
1744 let contents = if o.result_ok {
1745 let result = unsafe { o.contents.result };
1746 unsafe { o.contents.result = std::ptr::null_mut() };
1747 CResult_ChannelFeaturesDecodeErrorZPtr { result }
1749 let err = unsafe { o.contents.err };
1750 unsafe { o.contents.err = std::ptr::null_mut(); }
1751 CResult_ChannelFeaturesDecodeErrorZPtr { err }
1755 result_ok: o.result_ok,
1760 pub union CResult_InvoiceFeaturesDecodeErrorZPtr {
1761 pub result: *mut crate::ln::features::InvoiceFeatures,
1762 pub err: *mut crate::ln::msgs::DecodeError,
1765 pub struct CResult_InvoiceFeaturesDecodeErrorZ {
1766 pub contents: CResult_InvoiceFeaturesDecodeErrorZPtr,
1767 pub result_ok: bool,
1770 pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_ok(o: crate::ln::features::InvoiceFeatures) -> CResult_InvoiceFeaturesDecodeErrorZ {
1771 CResult_InvoiceFeaturesDecodeErrorZ {
1772 contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
1773 result: Box::into_raw(Box::new(o)),
1779 pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_InvoiceFeaturesDecodeErrorZ {
1780 CResult_InvoiceFeaturesDecodeErrorZ {
1781 contents: CResult_InvoiceFeaturesDecodeErrorZPtr {
1782 err: Box::into_raw(Box::new(e)),
1788 pub extern "C" fn CResult_InvoiceFeaturesDecodeErrorZ_free(_res: CResult_InvoiceFeaturesDecodeErrorZ) { }
1789 impl Drop for CResult_InvoiceFeaturesDecodeErrorZ {
1790 fn drop(&mut self) {
1792 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1793 let _ = unsafe { Box::from_raw(self.contents.result) };
1796 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1797 let _ = unsafe { Box::from_raw(self.contents.err) };
1802 impl From<crate::c_types::CResultTempl<crate::ln::features::InvoiceFeatures, crate::ln::msgs::DecodeError>> for CResult_InvoiceFeaturesDecodeErrorZ {
1803 fn from(mut o: crate::c_types::CResultTempl<crate::ln::features::InvoiceFeatures, crate::ln::msgs::DecodeError>) -> Self {
1804 let contents = if o.result_ok {
1805 let result = unsafe { o.contents.result };
1806 unsafe { o.contents.result = std::ptr::null_mut() };
1807 CResult_InvoiceFeaturesDecodeErrorZPtr { result }
1809 let err = unsafe { o.contents.err };
1810 unsafe { o.contents.err = std::ptr::null_mut(); }
1811 CResult_InvoiceFeaturesDecodeErrorZPtr { err }
1815 result_ok: o.result_ok,
1820 pub union CResult_ChannelConfigDecodeErrorZPtr {
1821 pub result: *mut crate::util::config::ChannelConfig,
1822 pub err: *mut crate::ln::msgs::DecodeError,
1825 pub struct CResult_ChannelConfigDecodeErrorZ {
1826 pub contents: CResult_ChannelConfigDecodeErrorZPtr,
1827 pub result_ok: bool,
1830 pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_ok(o: crate::util::config::ChannelConfig) -> CResult_ChannelConfigDecodeErrorZ {
1831 CResult_ChannelConfigDecodeErrorZ {
1832 contents: CResult_ChannelConfigDecodeErrorZPtr {
1833 result: Box::into_raw(Box::new(o)),
1839 pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelConfigDecodeErrorZ {
1840 CResult_ChannelConfigDecodeErrorZ {
1841 contents: CResult_ChannelConfigDecodeErrorZPtr {
1842 err: Box::into_raw(Box::new(e)),
1848 pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_free(_res: CResult_ChannelConfigDecodeErrorZ) { }
1849 impl Drop for CResult_ChannelConfigDecodeErrorZ {
1850 fn drop(&mut self) {
1852 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1853 let _ = unsafe { Box::from_raw(self.contents.result) };
1856 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1857 let _ = unsafe { Box::from_raw(self.contents.err) };
1862 impl From<crate::c_types::CResultTempl<crate::util::config::ChannelConfig, crate::ln::msgs::DecodeError>> for CResult_ChannelConfigDecodeErrorZ {
1863 fn from(mut o: crate::c_types::CResultTempl<crate::util::config::ChannelConfig, crate::ln::msgs::DecodeError>) -> Self {
1864 let contents = if o.result_ok {
1865 let result = unsafe { o.contents.result };
1866 unsafe { o.contents.result = std::ptr::null_mut() };
1867 CResult_ChannelConfigDecodeErrorZPtr { result }
1869 let err = unsafe { o.contents.err };
1870 unsafe { o.contents.err = std::ptr::null_mut(); }
1871 CResult_ChannelConfigDecodeErrorZPtr { err }
1875 result_ok: o.result_ok,
1879 impl Clone for CResult_ChannelConfigDecodeErrorZ {
1880 fn clone(&self) -> Self {
1882 Self { result_ok: true, contents: CResult_ChannelConfigDecodeErrorZPtr {
1883 result: Box::into_raw(Box::new(<crate::util::config::ChannelConfig>::clone(unsafe { &*self.contents.result })))
1886 Self { result_ok: false, contents: CResult_ChannelConfigDecodeErrorZPtr {
1887 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
1893 pub extern "C" fn CResult_ChannelConfigDecodeErrorZ_clone(orig: &CResult_ChannelConfigDecodeErrorZ) -> CResult_ChannelConfigDecodeErrorZ { orig.clone() }
1896 pub enum COption_u64Z {
1901 #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
1902 if let Self::Some(_) = self { true } else { false }
1904 #[allow(unused)] pub(crate) fn take(mut self) -> u64 {
1905 if let Self::Some(v) = self { v } else { unreachable!() }
1909 pub extern "C" fn COption_u64Z_some(o: u64) -> COption_u64Z {
1910 COption_u64Z::Some(o)
1913 pub extern "C" fn COption_u64Z_none() -> COption_u64Z {
1917 pub extern "C" fn COption_u64Z_free(_res: COption_u64Z) { }
1919 pub extern "C" fn COption_u64Z_clone(orig: &COption_u64Z) -> COption_u64Z { orig.clone() }
1921 pub union CResult_DirectionalChannelInfoDecodeErrorZPtr {
1922 pub result: *mut crate::routing::network_graph::DirectionalChannelInfo,
1923 pub err: *mut crate::ln::msgs::DecodeError,
1926 pub struct CResult_DirectionalChannelInfoDecodeErrorZ {
1927 pub contents: CResult_DirectionalChannelInfoDecodeErrorZPtr,
1928 pub result_ok: bool,
1931 pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: crate::routing::network_graph::DirectionalChannelInfo) -> CResult_DirectionalChannelInfoDecodeErrorZ {
1932 CResult_DirectionalChannelInfoDecodeErrorZ {
1933 contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
1934 result: Box::into_raw(Box::new(o)),
1940 pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_DirectionalChannelInfoDecodeErrorZ {
1941 CResult_DirectionalChannelInfoDecodeErrorZ {
1942 contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
1943 err: Box::into_raw(Box::new(e)),
1949 pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: CResult_DirectionalChannelInfoDecodeErrorZ) { }
1950 impl Drop for CResult_DirectionalChannelInfoDecodeErrorZ {
1951 fn drop(&mut self) {
1953 if unsafe { !(self.contents.result as *mut ()).is_null() } {
1954 let _ = unsafe { Box::from_raw(self.contents.result) };
1957 if unsafe { !(self.contents.err as *mut ()).is_null() } {
1958 let _ = unsafe { Box::from_raw(self.contents.err) };
1963 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::DirectionalChannelInfo, crate::ln::msgs::DecodeError>> for CResult_DirectionalChannelInfoDecodeErrorZ {
1964 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::DirectionalChannelInfo, crate::ln::msgs::DecodeError>) -> Self {
1965 let contents = if o.result_ok {
1966 let result = unsafe { o.contents.result };
1967 unsafe { o.contents.result = std::ptr::null_mut() };
1968 CResult_DirectionalChannelInfoDecodeErrorZPtr { result }
1970 let err = unsafe { o.contents.err };
1971 unsafe { o.contents.err = std::ptr::null_mut(); }
1972 CResult_DirectionalChannelInfoDecodeErrorZPtr { err }
1976 result_ok: o.result_ok,
1980 impl Clone for CResult_DirectionalChannelInfoDecodeErrorZ {
1981 fn clone(&self) -> Self {
1983 Self { result_ok: true, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
1984 result: Box::into_raw(Box::new(<crate::routing::network_graph::DirectionalChannelInfo>::clone(unsafe { &*self.contents.result })))
1987 Self { result_ok: false, contents: CResult_DirectionalChannelInfoDecodeErrorZPtr {
1988 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
1994 pub extern "C" fn CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: &CResult_DirectionalChannelInfoDecodeErrorZ) -> CResult_DirectionalChannelInfoDecodeErrorZ { orig.clone() }
1996 pub union CResult_ChannelInfoDecodeErrorZPtr {
1997 pub result: *mut crate::routing::network_graph::ChannelInfo,
1998 pub err: *mut crate::ln::msgs::DecodeError,
2001 pub struct CResult_ChannelInfoDecodeErrorZ {
2002 pub contents: CResult_ChannelInfoDecodeErrorZPtr,
2003 pub result_ok: bool,
2006 pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_ok(o: crate::routing::network_graph::ChannelInfo) -> CResult_ChannelInfoDecodeErrorZ {
2007 CResult_ChannelInfoDecodeErrorZ {
2008 contents: CResult_ChannelInfoDecodeErrorZPtr {
2009 result: Box::into_raw(Box::new(o)),
2015 pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelInfoDecodeErrorZ {
2016 CResult_ChannelInfoDecodeErrorZ {
2017 contents: CResult_ChannelInfoDecodeErrorZPtr {
2018 err: Box::into_raw(Box::new(e)),
2024 pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_free(_res: CResult_ChannelInfoDecodeErrorZ) { }
2025 impl Drop for CResult_ChannelInfoDecodeErrorZ {
2026 fn drop(&mut self) {
2028 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2029 let _ = unsafe { Box::from_raw(self.contents.result) };
2032 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2033 let _ = unsafe { Box::from_raw(self.contents.err) };
2038 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::ChannelInfo, crate::ln::msgs::DecodeError>> for CResult_ChannelInfoDecodeErrorZ {
2039 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::ChannelInfo, crate::ln::msgs::DecodeError>) -> Self {
2040 let contents = if o.result_ok {
2041 let result = unsafe { o.contents.result };
2042 unsafe { o.contents.result = std::ptr::null_mut() };
2043 CResult_ChannelInfoDecodeErrorZPtr { result }
2045 let err = unsafe { o.contents.err };
2046 unsafe { o.contents.err = std::ptr::null_mut(); }
2047 CResult_ChannelInfoDecodeErrorZPtr { err }
2051 result_ok: o.result_ok,
2055 impl Clone for CResult_ChannelInfoDecodeErrorZ {
2056 fn clone(&self) -> Self {
2058 Self { result_ok: true, contents: CResult_ChannelInfoDecodeErrorZPtr {
2059 result: Box::into_raw(Box::new(<crate::routing::network_graph::ChannelInfo>::clone(unsafe { &*self.contents.result })))
2062 Self { result_ok: false, contents: CResult_ChannelInfoDecodeErrorZPtr {
2063 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2069 pub extern "C" fn CResult_ChannelInfoDecodeErrorZ_clone(orig: &CResult_ChannelInfoDecodeErrorZ) -> CResult_ChannelInfoDecodeErrorZ { orig.clone() }
2071 pub union CResult_RoutingFeesDecodeErrorZPtr {
2072 pub result: *mut crate::routing::network_graph::RoutingFees,
2073 pub err: *mut crate::ln::msgs::DecodeError,
2076 pub struct CResult_RoutingFeesDecodeErrorZ {
2077 pub contents: CResult_RoutingFeesDecodeErrorZPtr,
2078 pub result_ok: bool,
2081 pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_ok(o: crate::routing::network_graph::RoutingFees) -> CResult_RoutingFeesDecodeErrorZ {
2082 CResult_RoutingFeesDecodeErrorZ {
2083 contents: CResult_RoutingFeesDecodeErrorZPtr {
2084 result: Box::into_raw(Box::new(o)),
2090 pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_RoutingFeesDecodeErrorZ {
2091 CResult_RoutingFeesDecodeErrorZ {
2092 contents: CResult_RoutingFeesDecodeErrorZPtr {
2093 err: Box::into_raw(Box::new(e)),
2099 pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_free(_res: CResult_RoutingFeesDecodeErrorZ) { }
2100 impl Drop for CResult_RoutingFeesDecodeErrorZ {
2101 fn drop(&mut self) {
2103 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2104 let _ = unsafe { Box::from_raw(self.contents.result) };
2107 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2108 let _ = unsafe { Box::from_raw(self.contents.err) };
2113 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::RoutingFees, crate::ln::msgs::DecodeError>> for CResult_RoutingFeesDecodeErrorZ {
2114 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::RoutingFees, crate::ln::msgs::DecodeError>) -> Self {
2115 let contents = if o.result_ok {
2116 let result = unsafe { o.contents.result };
2117 unsafe { o.contents.result = std::ptr::null_mut() };
2118 CResult_RoutingFeesDecodeErrorZPtr { result }
2120 let err = unsafe { o.contents.err };
2121 unsafe { o.contents.err = std::ptr::null_mut(); }
2122 CResult_RoutingFeesDecodeErrorZPtr { err }
2126 result_ok: o.result_ok,
2130 impl Clone for CResult_RoutingFeesDecodeErrorZ {
2131 fn clone(&self) -> Self {
2133 Self { result_ok: true, contents: CResult_RoutingFeesDecodeErrorZPtr {
2134 result: Box::into_raw(Box::new(<crate::routing::network_graph::RoutingFees>::clone(unsafe { &*self.contents.result })))
2137 Self { result_ok: false, contents: CResult_RoutingFeesDecodeErrorZPtr {
2138 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2144 pub extern "C" fn CResult_RoutingFeesDecodeErrorZ_clone(orig: &CResult_RoutingFeesDecodeErrorZ) -> CResult_RoutingFeesDecodeErrorZ { orig.clone() }
2146 pub struct CVec_NetAddressZ {
2147 pub data: *mut crate::ln::msgs::NetAddress,
2150 impl CVec_NetAddressZ {
2151 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::NetAddress> {
2152 if self.datalen == 0 { return Vec::new(); }
2153 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
2154 self.data = std::ptr::null_mut();
2158 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::NetAddress] {
2159 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
2162 impl From<Vec<crate::ln::msgs::NetAddress>> for CVec_NetAddressZ {
2163 fn from(v: Vec<crate::ln::msgs::NetAddress>) -> Self {
2164 let datalen = v.len();
2165 let data = Box::into_raw(v.into_boxed_slice());
2166 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
2170 pub extern "C" fn CVec_NetAddressZ_free(_res: CVec_NetAddressZ) { }
2171 impl Drop for CVec_NetAddressZ {
2172 fn drop(&mut self) {
2173 if self.datalen == 0 { return; }
2174 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
2177 impl Clone for CVec_NetAddressZ {
2178 fn clone(&self) -> Self {
2179 let mut res = Vec::new();
2180 if self.datalen == 0 { return Self::from(res); }
2181 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
2186 pub union CResult_NodeAnnouncementInfoDecodeErrorZPtr {
2187 pub result: *mut crate::routing::network_graph::NodeAnnouncementInfo,
2188 pub err: *mut crate::ln::msgs::DecodeError,
2191 pub struct CResult_NodeAnnouncementInfoDecodeErrorZ {
2192 pub contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr,
2193 pub result_ok: bool,
2196 pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: crate::routing::network_graph::NodeAnnouncementInfo) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
2197 CResult_NodeAnnouncementInfoDecodeErrorZ {
2198 contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
2199 result: Box::into_raw(Box::new(o)),
2205 pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_NodeAnnouncementInfoDecodeErrorZ {
2206 CResult_NodeAnnouncementInfoDecodeErrorZ {
2207 contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
2208 err: Box::into_raw(Box::new(e)),
2214 pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: CResult_NodeAnnouncementInfoDecodeErrorZ) { }
2215 impl Drop for CResult_NodeAnnouncementInfoDecodeErrorZ {
2216 fn drop(&mut self) {
2218 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2219 let _ = unsafe { Box::from_raw(self.contents.result) };
2222 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2223 let _ = unsafe { Box::from_raw(self.contents.err) };
2228 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::NodeAnnouncementInfo, crate::ln::msgs::DecodeError>> for CResult_NodeAnnouncementInfoDecodeErrorZ {
2229 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::NodeAnnouncementInfo, crate::ln::msgs::DecodeError>) -> Self {
2230 let contents = if o.result_ok {
2231 let result = unsafe { o.contents.result };
2232 unsafe { o.contents.result = std::ptr::null_mut() };
2233 CResult_NodeAnnouncementInfoDecodeErrorZPtr { result }
2235 let err = unsafe { o.contents.err };
2236 unsafe { o.contents.err = std::ptr::null_mut(); }
2237 CResult_NodeAnnouncementInfoDecodeErrorZPtr { err }
2241 result_ok: o.result_ok,
2245 impl Clone for CResult_NodeAnnouncementInfoDecodeErrorZ {
2246 fn clone(&self) -> Self {
2248 Self { result_ok: true, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
2249 result: Box::into_raw(Box::new(<crate::routing::network_graph::NodeAnnouncementInfo>::clone(unsafe { &*self.contents.result })))
2252 Self { result_ok: false, contents: CResult_NodeAnnouncementInfoDecodeErrorZPtr {
2253 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2259 pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementInfoDecodeErrorZ) -> CResult_NodeAnnouncementInfoDecodeErrorZ { orig.clone() }
2261 pub struct CVec_u64Z {
2266 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<u64> {
2267 if self.datalen == 0 { return Vec::new(); }
2268 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
2269 self.data = std::ptr::null_mut();
2273 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[u64] {
2274 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
2277 impl From<Vec<u64>> for CVec_u64Z {
2278 fn from(v: Vec<u64>) -> Self {
2279 let datalen = v.len();
2280 let data = Box::into_raw(v.into_boxed_slice());
2281 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
2285 pub extern "C" fn CVec_u64Z_free(_res: CVec_u64Z) { }
2286 impl Drop for CVec_u64Z {
2287 fn drop(&mut self) {
2288 if self.datalen == 0 { return; }
2289 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
2292 impl Clone for CVec_u64Z {
2293 fn clone(&self) -> Self {
2294 let mut res = Vec::new();
2295 if self.datalen == 0 { return Self::from(res); }
2296 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
2301 pub union CResult_NodeInfoDecodeErrorZPtr {
2302 pub result: *mut crate::routing::network_graph::NodeInfo,
2303 pub err: *mut crate::ln::msgs::DecodeError,
2306 pub struct CResult_NodeInfoDecodeErrorZ {
2307 pub contents: CResult_NodeInfoDecodeErrorZPtr,
2308 pub result_ok: bool,
2311 pub extern "C" fn CResult_NodeInfoDecodeErrorZ_ok(o: crate::routing::network_graph::NodeInfo) -> CResult_NodeInfoDecodeErrorZ {
2312 CResult_NodeInfoDecodeErrorZ {
2313 contents: CResult_NodeInfoDecodeErrorZPtr {
2314 result: Box::into_raw(Box::new(o)),
2320 pub extern "C" fn CResult_NodeInfoDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_NodeInfoDecodeErrorZ {
2321 CResult_NodeInfoDecodeErrorZ {
2322 contents: CResult_NodeInfoDecodeErrorZPtr {
2323 err: Box::into_raw(Box::new(e)),
2329 pub extern "C" fn CResult_NodeInfoDecodeErrorZ_free(_res: CResult_NodeInfoDecodeErrorZ) { }
2330 impl Drop for CResult_NodeInfoDecodeErrorZ {
2331 fn drop(&mut self) {
2333 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2334 let _ = unsafe { Box::from_raw(self.contents.result) };
2337 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2338 let _ = unsafe { Box::from_raw(self.contents.err) };
2343 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::NodeInfo, crate::ln::msgs::DecodeError>> for CResult_NodeInfoDecodeErrorZ {
2344 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::NodeInfo, crate::ln::msgs::DecodeError>) -> Self {
2345 let contents = if o.result_ok {
2346 let result = unsafe { o.contents.result };
2347 unsafe { o.contents.result = std::ptr::null_mut() };
2348 CResult_NodeInfoDecodeErrorZPtr { result }
2350 let err = unsafe { o.contents.err };
2351 unsafe { o.contents.err = std::ptr::null_mut(); }
2352 CResult_NodeInfoDecodeErrorZPtr { err }
2356 result_ok: o.result_ok,
2360 impl Clone for CResult_NodeInfoDecodeErrorZ {
2361 fn clone(&self) -> Self {
2363 Self { result_ok: true, contents: CResult_NodeInfoDecodeErrorZPtr {
2364 result: Box::into_raw(Box::new(<crate::routing::network_graph::NodeInfo>::clone(unsafe { &*self.contents.result })))
2367 Self { result_ok: false, contents: CResult_NodeInfoDecodeErrorZPtr {
2368 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2374 pub extern "C" fn CResult_NodeInfoDecodeErrorZ_clone(orig: &CResult_NodeInfoDecodeErrorZ) -> CResult_NodeInfoDecodeErrorZ { orig.clone() }
2376 pub union CResult_NetworkGraphDecodeErrorZPtr {
2377 pub result: *mut crate::routing::network_graph::NetworkGraph,
2378 pub err: *mut crate::ln::msgs::DecodeError,
2381 pub struct CResult_NetworkGraphDecodeErrorZ {
2382 pub contents: CResult_NetworkGraphDecodeErrorZPtr,
2383 pub result_ok: bool,
2386 pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_ok(o: crate::routing::network_graph::NetworkGraph) -> CResult_NetworkGraphDecodeErrorZ {
2387 CResult_NetworkGraphDecodeErrorZ {
2388 contents: CResult_NetworkGraphDecodeErrorZPtr {
2389 result: Box::into_raw(Box::new(o)),
2395 pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_NetworkGraphDecodeErrorZ {
2396 CResult_NetworkGraphDecodeErrorZ {
2397 contents: CResult_NetworkGraphDecodeErrorZPtr {
2398 err: Box::into_raw(Box::new(e)),
2404 pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_free(_res: CResult_NetworkGraphDecodeErrorZ) { }
2405 impl Drop for CResult_NetworkGraphDecodeErrorZ {
2406 fn drop(&mut self) {
2408 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2409 let _ = unsafe { Box::from_raw(self.contents.result) };
2412 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2413 let _ = unsafe { Box::from_raw(self.contents.err) };
2418 impl From<crate::c_types::CResultTempl<crate::routing::network_graph::NetworkGraph, crate::ln::msgs::DecodeError>> for CResult_NetworkGraphDecodeErrorZ {
2419 fn from(mut o: crate::c_types::CResultTempl<crate::routing::network_graph::NetworkGraph, crate::ln::msgs::DecodeError>) -> Self {
2420 let contents = if o.result_ok {
2421 let result = unsafe { o.contents.result };
2422 unsafe { o.contents.result = std::ptr::null_mut() };
2423 CResult_NetworkGraphDecodeErrorZPtr { result }
2425 let err = unsafe { o.contents.err };
2426 unsafe { o.contents.err = std::ptr::null_mut(); }
2427 CResult_NetworkGraphDecodeErrorZPtr { err }
2431 result_ok: o.result_ok,
2435 impl Clone for CResult_NetworkGraphDecodeErrorZ {
2436 fn clone(&self) -> Self {
2438 Self { result_ok: true, contents: CResult_NetworkGraphDecodeErrorZPtr {
2439 result: Box::into_raw(Box::new(<crate::routing::network_graph::NetworkGraph>::clone(unsafe { &*self.contents.result })))
2442 Self { result_ok: false, contents: CResult_NetworkGraphDecodeErrorZPtr {
2443 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2449 pub extern "C" fn CResult_NetworkGraphDecodeErrorZ_clone(orig: &CResult_NetworkGraphDecodeErrorZ) -> CResult_NetworkGraphDecodeErrorZ { orig.clone() }
2451 pub struct C2Tuple_usizeTransactionZ {
2453 pub b: crate::c_types::Transaction,
2455 impl From<(usize, crate::c_types::Transaction)> for C2Tuple_usizeTransactionZ {
2456 fn from (tup: (usize, crate::c_types::Transaction)) -> Self {
2463 impl C2Tuple_usizeTransactionZ {
2464 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (usize, crate::c_types::Transaction) {
2469 pub extern "C" fn C2Tuple_usizeTransactionZ_new(a: usize, b: crate::c_types::Transaction) -> C2Tuple_usizeTransactionZ {
2470 C2Tuple_usizeTransactionZ { a, b, }
2474 pub extern "C" fn C2Tuple_usizeTransactionZ_free(_res: C2Tuple_usizeTransactionZ) { }
2476 pub struct CVec_C2Tuple_usizeTransactionZZ {
2477 pub data: *mut crate::c_types::derived::C2Tuple_usizeTransactionZ,
2480 impl CVec_C2Tuple_usizeTransactionZZ {
2481 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ> {
2482 if self.datalen == 0 { return Vec::new(); }
2483 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
2484 self.data = std::ptr::null_mut();
2488 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_usizeTransactionZ] {
2489 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
2492 impl From<Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>> for CVec_C2Tuple_usizeTransactionZZ {
2493 fn from(v: Vec<crate::c_types::derived::C2Tuple_usizeTransactionZ>) -> Self {
2494 let datalen = v.len();
2495 let data = Box::into_raw(v.into_boxed_slice());
2496 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
2500 pub extern "C" fn CVec_C2Tuple_usizeTransactionZZ_free(_res: CVec_C2Tuple_usizeTransactionZZ) { }
2501 impl Drop for CVec_C2Tuple_usizeTransactionZZ {
2502 fn drop(&mut self) {
2503 if self.datalen == 0 { return; }
2504 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
2508 pub union CResult_NoneChannelMonitorUpdateErrZPtr {
2509 /// Note that this value is always NULL, as there are no contents in the OK variant
2510 pub result: *mut std::ffi::c_void,
2511 pub err: *mut crate::chain::channelmonitor::ChannelMonitorUpdateErr,
2514 pub struct CResult_NoneChannelMonitorUpdateErrZ {
2515 pub contents: CResult_NoneChannelMonitorUpdateErrZPtr,
2516 pub result_ok: bool,
2519 pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_ok() -> CResult_NoneChannelMonitorUpdateErrZ {
2520 CResult_NoneChannelMonitorUpdateErrZ {
2521 contents: CResult_NoneChannelMonitorUpdateErrZPtr {
2522 result: std::ptr::null_mut(),
2528 pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_err(e: crate::chain::channelmonitor::ChannelMonitorUpdateErr) -> CResult_NoneChannelMonitorUpdateErrZ {
2529 CResult_NoneChannelMonitorUpdateErrZ {
2530 contents: CResult_NoneChannelMonitorUpdateErrZPtr {
2531 err: Box::into_raw(Box::new(e)),
2537 pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_free(_res: CResult_NoneChannelMonitorUpdateErrZ) { }
2538 impl Drop for CResult_NoneChannelMonitorUpdateErrZ {
2539 fn drop(&mut self) {
2542 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2543 let _ = unsafe { Box::from_raw(self.contents.err) };
2548 impl From<crate::c_types::CResultTempl<u8, crate::chain::channelmonitor::ChannelMonitorUpdateErr>> for CResult_NoneChannelMonitorUpdateErrZ {
2549 fn from(mut o: crate::c_types::CResultTempl<u8, crate::chain::channelmonitor::ChannelMonitorUpdateErr>) -> Self {
2550 let contents = if o.result_ok {
2551 let _ = unsafe { Box::from_raw(o.contents.result) };
2552 o.contents.result = std::ptr::null_mut();
2553 CResult_NoneChannelMonitorUpdateErrZPtr { result: std::ptr::null_mut() }
2555 let err = unsafe { o.contents.err };
2556 unsafe { o.contents.err = std::ptr::null_mut(); }
2557 CResult_NoneChannelMonitorUpdateErrZPtr { err }
2561 result_ok: o.result_ok,
2565 impl Clone for CResult_NoneChannelMonitorUpdateErrZ {
2566 fn clone(&self) -> Self {
2568 Self { result_ok: true, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
2569 result: std::ptr::null_mut()
2572 Self { result_ok: false, contents: CResult_NoneChannelMonitorUpdateErrZPtr {
2573 err: Box::into_raw(Box::new(<crate::chain::channelmonitor::ChannelMonitorUpdateErr>::clone(unsafe { &*self.contents.err })))
2579 pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_clone(orig: &CResult_NoneChannelMonitorUpdateErrZ) -> CResult_NoneChannelMonitorUpdateErrZ { orig.clone() }
2581 pub struct CVec_MonitorEventZ {
2582 pub data: *mut crate::chain::channelmonitor::MonitorEvent,
2585 impl CVec_MonitorEventZ {
2586 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::chain::channelmonitor::MonitorEvent> {
2587 if self.datalen == 0 { return Vec::new(); }
2588 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
2589 self.data = std::ptr::null_mut();
2593 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::chain::channelmonitor::MonitorEvent] {
2594 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
2597 impl From<Vec<crate::chain::channelmonitor::MonitorEvent>> for CVec_MonitorEventZ {
2598 fn from(v: Vec<crate::chain::channelmonitor::MonitorEvent>) -> Self {
2599 let datalen = v.len();
2600 let data = Box::into_raw(v.into_boxed_slice());
2601 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
2605 pub extern "C" fn CVec_MonitorEventZ_free(_res: CVec_MonitorEventZ) { }
2606 impl Drop for CVec_MonitorEventZ {
2607 fn drop(&mut self) {
2608 if self.datalen == 0 { return; }
2609 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
2612 impl Clone for CVec_MonitorEventZ {
2613 fn clone(&self) -> Self {
2614 let mut res = Vec::new();
2615 if self.datalen == 0 { return Self::from(res); }
2616 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
2621 pub struct CVec_EventZ {
2622 pub data: *mut crate::util::events::Event,
2626 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::util::events::Event> {
2627 if self.datalen == 0 { return Vec::new(); }
2628 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
2629 self.data = std::ptr::null_mut();
2633 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::util::events::Event] {
2634 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
2637 impl From<Vec<crate::util::events::Event>> for CVec_EventZ {
2638 fn from(v: Vec<crate::util::events::Event>) -> Self {
2639 let datalen = v.len();
2640 let data = Box::into_raw(v.into_boxed_slice());
2641 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
2645 pub extern "C" fn CVec_EventZ_free(_res: CVec_EventZ) { }
2646 impl Drop for CVec_EventZ {
2647 fn drop(&mut self) {
2648 if self.datalen == 0 { return; }
2649 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
2652 impl Clone for CVec_EventZ {
2653 fn clone(&self) -> Self {
2654 let mut res = Vec::new();
2655 if self.datalen == 0 { return Self::from(res); }
2656 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
2661 pub union CResult_OutPointDecodeErrorZPtr {
2662 pub result: *mut crate::chain::transaction::OutPoint,
2663 pub err: *mut crate::ln::msgs::DecodeError,
2666 pub struct CResult_OutPointDecodeErrorZ {
2667 pub contents: CResult_OutPointDecodeErrorZPtr,
2668 pub result_ok: bool,
2671 pub extern "C" fn CResult_OutPointDecodeErrorZ_ok(o: crate::chain::transaction::OutPoint) -> CResult_OutPointDecodeErrorZ {
2672 CResult_OutPointDecodeErrorZ {
2673 contents: CResult_OutPointDecodeErrorZPtr {
2674 result: Box::into_raw(Box::new(o)),
2680 pub extern "C" fn CResult_OutPointDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_OutPointDecodeErrorZ {
2681 CResult_OutPointDecodeErrorZ {
2682 contents: CResult_OutPointDecodeErrorZPtr {
2683 err: Box::into_raw(Box::new(e)),
2689 pub extern "C" fn CResult_OutPointDecodeErrorZ_free(_res: CResult_OutPointDecodeErrorZ) { }
2690 impl Drop for CResult_OutPointDecodeErrorZ {
2691 fn drop(&mut self) {
2693 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2694 let _ = unsafe { Box::from_raw(self.contents.result) };
2697 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2698 let _ = unsafe { Box::from_raw(self.contents.err) };
2703 impl From<crate::c_types::CResultTempl<crate::chain::transaction::OutPoint, crate::ln::msgs::DecodeError>> for CResult_OutPointDecodeErrorZ {
2704 fn from(mut o: crate::c_types::CResultTempl<crate::chain::transaction::OutPoint, crate::ln::msgs::DecodeError>) -> Self {
2705 let contents = if o.result_ok {
2706 let result = unsafe { o.contents.result };
2707 unsafe { o.contents.result = std::ptr::null_mut() };
2708 CResult_OutPointDecodeErrorZPtr { result }
2710 let err = unsafe { o.contents.err };
2711 unsafe { o.contents.err = std::ptr::null_mut(); }
2712 CResult_OutPointDecodeErrorZPtr { err }
2716 result_ok: o.result_ok,
2720 impl Clone for CResult_OutPointDecodeErrorZ {
2721 fn clone(&self) -> Self {
2723 Self { result_ok: true, contents: CResult_OutPointDecodeErrorZPtr {
2724 result: Box::into_raw(Box::new(<crate::chain::transaction::OutPoint>::clone(unsafe { &*self.contents.result })))
2727 Self { result_ok: false, contents: CResult_OutPointDecodeErrorZPtr {
2728 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2734 pub extern "C" fn CResult_OutPointDecodeErrorZ_clone(orig: &CResult_OutPointDecodeErrorZ) -> CResult_OutPointDecodeErrorZ { orig.clone() }
2736 pub union CResult_ChannelMonitorUpdateDecodeErrorZPtr {
2737 pub result: *mut crate::chain::channelmonitor::ChannelMonitorUpdate,
2738 pub err: *mut crate::ln::msgs::DecodeError,
2741 pub struct CResult_ChannelMonitorUpdateDecodeErrorZ {
2742 pub contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr,
2743 pub result_ok: bool,
2746 pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: crate::chain::channelmonitor::ChannelMonitorUpdate) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
2747 CResult_ChannelMonitorUpdateDecodeErrorZ {
2748 contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
2749 result: Box::into_raw(Box::new(o)),
2755 pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelMonitorUpdateDecodeErrorZ {
2756 CResult_ChannelMonitorUpdateDecodeErrorZ {
2757 contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
2758 err: Box::into_raw(Box::new(e)),
2764 pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: CResult_ChannelMonitorUpdateDecodeErrorZ) { }
2765 impl Drop for CResult_ChannelMonitorUpdateDecodeErrorZ {
2766 fn drop(&mut self) {
2768 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2769 let _ = unsafe { Box::from_raw(self.contents.result) };
2772 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2773 let _ = unsafe { Box::from_raw(self.contents.err) };
2778 impl From<crate::c_types::CResultTempl<crate::chain::channelmonitor::ChannelMonitorUpdate, crate::ln::msgs::DecodeError>> for CResult_ChannelMonitorUpdateDecodeErrorZ {
2779 fn from(mut o: crate::c_types::CResultTempl<crate::chain::channelmonitor::ChannelMonitorUpdate, crate::ln::msgs::DecodeError>) -> Self {
2780 let contents = if o.result_ok {
2781 let result = unsafe { o.contents.result };
2782 unsafe { o.contents.result = std::ptr::null_mut() };
2783 CResult_ChannelMonitorUpdateDecodeErrorZPtr { result }
2785 let err = unsafe { o.contents.err };
2786 unsafe { o.contents.err = std::ptr::null_mut(); }
2787 CResult_ChannelMonitorUpdateDecodeErrorZPtr { err }
2791 result_ok: o.result_ok,
2795 impl Clone for CResult_ChannelMonitorUpdateDecodeErrorZ {
2796 fn clone(&self) -> Self {
2798 Self { result_ok: true, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
2799 result: Box::into_raw(Box::new(<crate::chain::channelmonitor::ChannelMonitorUpdate>::clone(unsafe { &*self.contents.result })))
2802 Self { result_ok: false, contents: CResult_ChannelMonitorUpdateDecodeErrorZPtr {
2803 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2809 pub extern "C" fn CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: &CResult_ChannelMonitorUpdateDecodeErrorZ) -> CResult_ChannelMonitorUpdateDecodeErrorZ { orig.clone() }
2811 pub union CResult_HTLCUpdateDecodeErrorZPtr {
2812 pub result: *mut crate::chain::channelmonitor::HTLCUpdate,
2813 pub err: *mut crate::ln::msgs::DecodeError,
2816 pub struct CResult_HTLCUpdateDecodeErrorZ {
2817 pub contents: CResult_HTLCUpdateDecodeErrorZPtr,
2818 pub result_ok: bool,
2821 pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_ok(o: crate::chain::channelmonitor::HTLCUpdate) -> CResult_HTLCUpdateDecodeErrorZ {
2822 CResult_HTLCUpdateDecodeErrorZ {
2823 contents: CResult_HTLCUpdateDecodeErrorZPtr {
2824 result: Box::into_raw(Box::new(o)),
2830 pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_HTLCUpdateDecodeErrorZ {
2831 CResult_HTLCUpdateDecodeErrorZ {
2832 contents: CResult_HTLCUpdateDecodeErrorZPtr {
2833 err: Box::into_raw(Box::new(e)),
2839 pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_free(_res: CResult_HTLCUpdateDecodeErrorZ) { }
2840 impl Drop for CResult_HTLCUpdateDecodeErrorZ {
2841 fn drop(&mut self) {
2843 if unsafe { !(self.contents.result as *mut ()).is_null() } {
2844 let _ = unsafe { Box::from_raw(self.contents.result) };
2847 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2848 let _ = unsafe { Box::from_raw(self.contents.err) };
2853 impl From<crate::c_types::CResultTempl<crate::chain::channelmonitor::HTLCUpdate, crate::ln::msgs::DecodeError>> for CResult_HTLCUpdateDecodeErrorZ {
2854 fn from(mut o: crate::c_types::CResultTempl<crate::chain::channelmonitor::HTLCUpdate, crate::ln::msgs::DecodeError>) -> Self {
2855 let contents = if o.result_ok {
2856 let result = unsafe { o.contents.result };
2857 unsafe { o.contents.result = std::ptr::null_mut() };
2858 CResult_HTLCUpdateDecodeErrorZPtr { result }
2860 let err = unsafe { o.contents.err };
2861 unsafe { o.contents.err = std::ptr::null_mut(); }
2862 CResult_HTLCUpdateDecodeErrorZPtr { err }
2866 result_ok: o.result_ok,
2870 impl Clone for CResult_HTLCUpdateDecodeErrorZ {
2871 fn clone(&self) -> Self {
2873 Self { result_ok: true, contents: CResult_HTLCUpdateDecodeErrorZPtr {
2874 result: Box::into_raw(Box::new(<crate::chain::channelmonitor::HTLCUpdate>::clone(unsafe { &*self.contents.result })))
2877 Self { result_ok: false, contents: CResult_HTLCUpdateDecodeErrorZPtr {
2878 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
2884 pub extern "C" fn CResult_HTLCUpdateDecodeErrorZ_clone(orig: &CResult_HTLCUpdateDecodeErrorZ) -> CResult_HTLCUpdateDecodeErrorZ { orig.clone() }
2886 pub union CResult_NoneMonitorUpdateErrorZPtr {
2887 /// Note that this value is always NULL, as there are no contents in the OK variant
2888 pub result: *mut std::ffi::c_void,
2889 pub err: *mut crate::chain::channelmonitor::MonitorUpdateError,
2892 pub struct CResult_NoneMonitorUpdateErrorZ {
2893 pub contents: CResult_NoneMonitorUpdateErrorZPtr,
2894 pub result_ok: bool,
2897 pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_ok() -> CResult_NoneMonitorUpdateErrorZ {
2898 CResult_NoneMonitorUpdateErrorZ {
2899 contents: CResult_NoneMonitorUpdateErrorZPtr {
2900 result: std::ptr::null_mut(),
2906 pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_err(e: crate::chain::channelmonitor::MonitorUpdateError) -> CResult_NoneMonitorUpdateErrorZ {
2907 CResult_NoneMonitorUpdateErrorZ {
2908 contents: CResult_NoneMonitorUpdateErrorZPtr {
2909 err: Box::into_raw(Box::new(e)),
2915 pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_free(_res: CResult_NoneMonitorUpdateErrorZ) { }
2916 impl Drop for CResult_NoneMonitorUpdateErrorZ {
2917 fn drop(&mut self) {
2920 if unsafe { !(self.contents.err as *mut ()).is_null() } {
2921 let _ = unsafe { Box::from_raw(self.contents.err) };
2926 impl From<crate::c_types::CResultTempl<u8, crate::chain::channelmonitor::MonitorUpdateError>> for CResult_NoneMonitorUpdateErrorZ {
2927 fn from(mut o: crate::c_types::CResultTempl<u8, crate::chain::channelmonitor::MonitorUpdateError>) -> Self {
2928 let contents = if o.result_ok {
2929 let _ = unsafe { Box::from_raw(o.contents.result) };
2930 o.contents.result = std::ptr::null_mut();
2931 CResult_NoneMonitorUpdateErrorZPtr { result: std::ptr::null_mut() }
2933 let err = unsafe { o.contents.err };
2934 unsafe { o.contents.err = std::ptr::null_mut(); }
2935 CResult_NoneMonitorUpdateErrorZPtr { err }
2939 result_ok: o.result_ok,
2943 impl Clone for CResult_NoneMonitorUpdateErrorZ {
2944 fn clone(&self) -> Self {
2946 Self { result_ok: true, contents: CResult_NoneMonitorUpdateErrorZPtr {
2947 result: std::ptr::null_mut()
2950 Self { result_ok: false, contents: CResult_NoneMonitorUpdateErrorZPtr {
2951 err: Box::into_raw(Box::new(<crate::chain::channelmonitor::MonitorUpdateError>::clone(unsafe { &*self.contents.err })))
2957 pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_clone(orig: &CResult_NoneMonitorUpdateErrorZ) -> CResult_NoneMonitorUpdateErrorZ { orig.clone() }
2959 pub struct C2Tuple_OutPointScriptZ {
2960 pub a: crate::chain::transaction::OutPoint,
2961 pub b: crate::c_types::derived::CVec_u8Z,
2963 impl From<(crate::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)> for C2Tuple_OutPointScriptZ {
2964 fn from (tup: (crate::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z)) -> Self {
2971 impl C2Tuple_OutPointScriptZ {
2972 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::chain::transaction::OutPoint, crate::c_types::derived::CVec_u8Z) {
2976 impl Clone for C2Tuple_OutPointScriptZ {
2977 fn clone(&self) -> Self {
2985 pub extern "C" fn C2Tuple_OutPointScriptZ_clone(orig: &C2Tuple_OutPointScriptZ) -> C2Tuple_OutPointScriptZ { orig.clone() }
2987 pub extern "C" fn C2Tuple_OutPointScriptZ_new(a: crate::chain::transaction::OutPoint, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_OutPointScriptZ {
2988 C2Tuple_OutPointScriptZ { a, b, }
2992 pub extern "C" fn C2Tuple_OutPointScriptZ_free(_res: C2Tuple_OutPointScriptZ) { }
2994 pub struct C2Tuple_u32ScriptZ {
2996 pub b: crate::c_types::derived::CVec_u8Z,
2998 impl From<(u32, crate::c_types::derived::CVec_u8Z)> for C2Tuple_u32ScriptZ {
2999 fn from (tup: (u32, crate::c_types::derived::CVec_u8Z)) -> Self {
3006 impl C2Tuple_u32ScriptZ {
3007 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::derived::CVec_u8Z) {
3011 impl Clone for C2Tuple_u32ScriptZ {
3012 fn clone(&self) -> Self {
3020 pub extern "C" fn C2Tuple_u32ScriptZ_clone(orig: &C2Tuple_u32ScriptZ) -> C2Tuple_u32ScriptZ { orig.clone() }
3022 pub extern "C" fn C2Tuple_u32ScriptZ_new(a: u32, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_u32ScriptZ {
3023 C2Tuple_u32ScriptZ { a, b, }
3027 pub extern "C" fn C2Tuple_u32ScriptZ_free(_res: C2Tuple_u32ScriptZ) { }
3029 pub struct CVec_C2Tuple_u32ScriptZZ {
3030 pub data: *mut crate::c_types::derived::C2Tuple_u32ScriptZ,
3033 impl CVec_C2Tuple_u32ScriptZZ {
3034 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32ScriptZ> {
3035 if self.datalen == 0 { return Vec::new(); }
3036 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3037 self.data = std::ptr::null_mut();
3041 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32ScriptZ] {
3042 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3045 impl From<Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>> for CVec_C2Tuple_u32ScriptZZ {
3046 fn from(v: Vec<crate::c_types::derived::C2Tuple_u32ScriptZ>) -> Self {
3047 let datalen = v.len();
3048 let data = Box::into_raw(v.into_boxed_slice());
3049 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3053 pub extern "C" fn CVec_C2Tuple_u32ScriptZZ_free(_res: CVec_C2Tuple_u32ScriptZZ) { }
3054 impl Drop for CVec_C2Tuple_u32ScriptZZ {
3055 fn drop(&mut self) {
3056 if self.datalen == 0 { return; }
3057 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3060 impl Clone for CVec_C2Tuple_u32ScriptZZ {
3061 fn clone(&self) -> Self {
3062 let mut res = Vec::new();
3063 if self.datalen == 0 { return Self::from(res); }
3064 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3069 pub struct C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
3070 pub a: crate::c_types::ThirtyTwoBytes,
3071 pub b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ,
3073 impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)> for C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
3074 fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ)) -> Self {
3081 impl C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
3082 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) {
3087 pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32ScriptZZ) -> C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
3088 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ { a, b, }
3092 pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) { }
3094 pub struct CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
3095 pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ,
3098 impl CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
3099 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ> {
3100 if self.datalen == 0 { return Vec::new(); }
3101 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3102 self.data = std::ptr::null_mut();
3106 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ] {
3107 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3110 impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>> for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
3111 fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ>) -> Self {
3112 let datalen = v.len();
3113 let data = Box::into_raw(v.into_boxed_slice());
3114 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3118 pub extern "C" fn CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ) { }
3119 impl Drop for CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
3120 fn drop(&mut self) {
3121 if self.datalen == 0 { return; }
3122 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3126 pub struct CVec_TransactionZ {
3127 pub data: *mut crate::c_types::Transaction,
3130 impl CVec_TransactionZ {
3131 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::Transaction> {
3132 if self.datalen == 0 { return Vec::new(); }
3133 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3134 self.data = std::ptr::null_mut();
3138 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::Transaction] {
3139 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3142 impl From<Vec<crate::c_types::Transaction>> for CVec_TransactionZ {
3143 fn from(v: Vec<crate::c_types::Transaction>) -> Self {
3144 let datalen = v.len();
3145 let data = Box::into_raw(v.into_boxed_slice());
3146 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3150 pub extern "C" fn CVec_TransactionZ_free(_res: CVec_TransactionZ) { }
3151 impl Drop for CVec_TransactionZ {
3152 fn drop(&mut self) {
3153 if self.datalen == 0 { return; }
3154 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3158 pub struct C2Tuple_u32TxOutZ {
3160 pub b: crate::c_types::TxOut,
3162 impl From<(u32, crate::c_types::TxOut)> for C2Tuple_u32TxOutZ {
3163 fn from (tup: (u32, crate::c_types::TxOut)) -> Self {
3170 impl C2Tuple_u32TxOutZ {
3171 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u32, crate::c_types::TxOut) {
3175 impl Clone for C2Tuple_u32TxOutZ {
3176 fn clone(&self) -> Self {
3184 pub extern "C" fn C2Tuple_u32TxOutZ_clone(orig: &C2Tuple_u32TxOutZ) -> C2Tuple_u32TxOutZ { orig.clone() }
3186 pub extern "C" fn C2Tuple_u32TxOutZ_new(a: u32, b: crate::c_types::TxOut) -> C2Tuple_u32TxOutZ {
3187 C2Tuple_u32TxOutZ { a, b, }
3191 pub extern "C" fn C2Tuple_u32TxOutZ_free(_res: C2Tuple_u32TxOutZ) { }
3193 pub struct CVec_C2Tuple_u32TxOutZZ {
3194 pub data: *mut crate::c_types::derived::C2Tuple_u32TxOutZ,
3197 impl CVec_C2Tuple_u32TxOutZZ {
3198 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_u32TxOutZ> {
3199 if self.datalen == 0 { return Vec::new(); }
3200 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3201 self.data = std::ptr::null_mut();
3205 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_u32TxOutZ] {
3206 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3209 impl From<Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>> for CVec_C2Tuple_u32TxOutZZ {
3210 fn from(v: Vec<crate::c_types::derived::C2Tuple_u32TxOutZ>) -> Self {
3211 let datalen = v.len();
3212 let data = Box::into_raw(v.into_boxed_slice());
3213 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3217 pub extern "C" fn CVec_C2Tuple_u32TxOutZZ_free(_res: CVec_C2Tuple_u32TxOutZZ) { }
3218 impl Drop for CVec_C2Tuple_u32TxOutZZ {
3219 fn drop(&mut self) {
3220 if self.datalen == 0 { return; }
3221 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3224 impl Clone for CVec_C2Tuple_u32TxOutZZ {
3225 fn clone(&self) -> Self {
3226 let mut res = Vec::new();
3227 if self.datalen == 0 { return Self::from(res); }
3228 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3233 pub struct C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
3234 pub a: crate::c_types::ThirtyTwoBytes,
3235 pub b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ,
3237 impl From<(crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)> for C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
3238 fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ)) -> Self {
3245 impl C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
3246 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) {
3251 pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::c_types::derived::CVec_C2Tuple_u32TxOutZZ) -> C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
3252 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ { a, b, }
3256 pub extern "C" fn C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) { }
3258 pub struct CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
3259 pub data: *mut crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ,
3262 impl CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
3263 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ> {
3264 if self.datalen == 0 { return Vec::new(); }
3265 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3266 self.data = std::ptr::null_mut();
3270 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ] {
3271 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3274 impl From<Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>> for CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
3275 fn from(v: Vec<crate::c_types::derived::C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ>) -> Self {
3276 let datalen = v.len();
3277 let data = Box::into_raw(v.into_boxed_slice());
3278 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3282 pub extern "C" fn CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ) { }
3283 impl Drop for CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
3284 fn drop(&mut self) {
3285 if self.datalen == 0 { return; }
3286 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3290 pub struct C2Tuple_BlockHashChannelMonitorZ {
3291 pub a: crate::c_types::ThirtyTwoBytes,
3292 pub b: crate::chain::channelmonitor::ChannelMonitor,
3294 impl From<(crate::c_types::ThirtyTwoBytes, crate::chain::channelmonitor::ChannelMonitor)> for C2Tuple_BlockHashChannelMonitorZ {
3295 fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::chain::channelmonitor::ChannelMonitor)) -> Self {
3302 impl C2Tuple_BlockHashChannelMonitorZ {
3303 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::chain::channelmonitor::ChannelMonitor) {
3308 pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::chain::channelmonitor::ChannelMonitor) -> C2Tuple_BlockHashChannelMonitorZ {
3309 C2Tuple_BlockHashChannelMonitorZ { a, b, }
3313 pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_free(_res: C2Tuple_BlockHashChannelMonitorZ) { }
3315 pub union CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
3316 pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ,
3317 pub err: *mut crate::ln::msgs::DecodeError,
3320 pub struct CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3321 pub contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr,
3322 pub result_ok: bool,
3325 pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3326 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3327 contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
3328 result: Box::into_raw(Box::new(o)),
3334 pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3335 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3336 contents: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr {
3337 err: Box::into_raw(Box::new(e)),
3343 pub extern "C" fn CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ) { }
3344 impl Drop for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3345 fn drop(&mut self) {
3347 if unsafe { !(self.contents.result as *mut ()).is_null() } {
3348 let _ = unsafe { Box::from_raw(self.contents.result) };
3351 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3352 let _ = unsafe { Box::from_raw(self.contents.err) };
3357 impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
3358 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelMonitorZ, crate::ln::msgs::DecodeError>) -> Self {
3359 let contents = if o.result_ok {
3360 let result = unsafe { o.contents.result };
3361 unsafe { o.contents.result = std::ptr::null_mut() };
3362 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { result }
3364 let err = unsafe { o.contents.err };
3365 unsafe { o.contents.err = std::ptr::null_mut(); }
3366 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr { err }
3370 result_ok: o.result_ok,
3375 pub struct CVec_SpendableOutputDescriptorZ {
3376 pub data: *mut crate::chain::keysinterface::SpendableOutputDescriptor,
3379 impl CVec_SpendableOutputDescriptorZ {
3380 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::chain::keysinterface::SpendableOutputDescriptor> {
3381 if self.datalen == 0 { return Vec::new(); }
3382 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3383 self.data = std::ptr::null_mut();
3387 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::chain::keysinterface::SpendableOutputDescriptor] {
3388 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3391 impl From<Vec<crate::chain::keysinterface::SpendableOutputDescriptor>> for CVec_SpendableOutputDescriptorZ {
3392 fn from(v: Vec<crate::chain::keysinterface::SpendableOutputDescriptor>) -> Self {
3393 let datalen = v.len();
3394 let data = Box::into_raw(v.into_boxed_slice());
3395 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3399 pub extern "C" fn CVec_SpendableOutputDescriptorZ_free(_res: CVec_SpendableOutputDescriptorZ) { }
3400 impl Drop for CVec_SpendableOutputDescriptorZ {
3401 fn drop(&mut self) {
3402 if self.datalen == 0 { return; }
3403 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3406 impl Clone for CVec_SpendableOutputDescriptorZ {
3407 fn clone(&self) -> Self {
3408 let mut res = Vec::new();
3409 if self.datalen == 0 { return Self::from(res); }
3410 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3415 pub union CResult_TxOutAccessErrorZPtr {
3416 pub result: *mut crate::c_types::TxOut,
3417 pub err: *mut crate::chain::AccessError,
3420 pub struct CResult_TxOutAccessErrorZ {
3421 pub contents: CResult_TxOutAccessErrorZPtr,
3422 pub result_ok: bool,
3425 pub extern "C" fn CResult_TxOutAccessErrorZ_ok(o: crate::c_types::TxOut) -> CResult_TxOutAccessErrorZ {
3426 CResult_TxOutAccessErrorZ {
3427 contents: CResult_TxOutAccessErrorZPtr {
3428 result: Box::into_raw(Box::new(o)),
3434 pub extern "C" fn CResult_TxOutAccessErrorZ_err(e: crate::chain::AccessError) -> CResult_TxOutAccessErrorZ {
3435 CResult_TxOutAccessErrorZ {
3436 contents: CResult_TxOutAccessErrorZPtr {
3437 err: Box::into_raw(Box::new(e)),
3443 pub extern "C" fn CResult_TxOutAccessErrorZ_free(_res: CResult_TxOutAccessErrorZ) { }
3444 impl Drop for CResult_TxOutAccessErrorZ {
3445 fn drop(&mut self) {
3447 if unsafe { !(self.contents.result as *mut ()).is_null() } {
3448 let _ = unsafe { Box::from_raw(self.contents.result) };
3451 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3452 let _ = unsafe { Box::from_raw(self.contents.err) };
3457 impl From<crate::c_types::CResultTempl<crate::c_types::TxOut, crate::chain::AccessError>> for CResult_TxOutAccessErrorZ {
3458 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::TxOut, crate::chain::AccessError>) -> Self {
3459 let contents = if o.result_ok {
3460 let result = unsafe { o.contents.result };
3461 unsafe { o.contents.result = std::ptr::null_mut() };
3462 CResult_TxOutAccessErrorZPtr { result }
3464 let err = unsafe { o.contents.err };
3465 unsafe { o.contents.err = std::ptr::null_mut(); }
3466 CResult_TxOutAccessErrorZPtr { err }
3470 result_ok: o.result_ok,
3474 impl Clone for CResult_TxOutAccessErrorZ {
3475 fn clone(&self) -> Self {
3477 Self { result_ok: true, contents: CResult_TxOutAccessErrorZPtr {
3478 result: Box::into_raw(Box::new(<crate::c_types::TxOut>::clone(unsafe { &*self.contents.result })))
3481 Self { result_ok: false, contents: CResult_TxOutAccessErrorZPtr {
3482 err: Box::into_raw(Box::new(<crate::chain::AccessError>::clone(unsafe { &*self.contents.err })))
3488 pub extern "C" fn CResult_TxOutAccessErrorZ_clone(orig: &CResult_TxOutAccessErrorZ) -> CResult_TxOutAccessErrorZ { orig.clone() }
3490 pub enum COption_C2Tuple_usizeTransactionZZ {
3491 Some(crate::c_types::derived::C2Tuple_usizeTransactionZ),
3494 impl COption_C2Tuple_usizeTransactionZZ {
3495 #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
3496 if let Self::Some(_) = self { true } else { false }
3498 #[allow(unused)] pub(crate) fn take(mut self) -> crate::c_types::derived::C2Tuple_usizeTransactionZ {
3499 if let Self::Some(v) = self { v } else { unreachable!() }
3503 pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_some(o: crate::c_types::derived::C2Tuple_usizeTransactionZ) -> COption_C2Tuple_usizeTransactionZZ {
3504 COption_C2Tuple_usizeTransactionZZ::Some(o)
3507 pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_none() -> COption_C2Tuple_usizeTransactionZZ {
3508 COption_C2Tuple_usizeTransactionZZ::None
3511 pub extern "C" fn COption_C2Tuple_usizeTransactionZZ_free(_res: COption_C2Tuple_usizeTransactionZZ) { }
3513 pub union CResult_NoneAPIErrorZPtr {
3514 /// Note that this value is always NULL, as there are no contents in the OK variant
3515 pub result: *mut std::ffi::c_void,
3516 pub err: *mut crate::util::errors::APIError,
3519 pub struct CResult_NoneAPIErrorZ {
3520 pub contents: CResult_NoneAPIErrorZPtr,
3521 pub result_ok: bool,
3524 pub extern "C" fn CResult_NoneAPIErrorZ_ok() -> CResult_NoneAPIErrorZ {
3525 CResult_NoneAPIErrorZ {
3526 contents: CResult_NoneAPIErrorZPtr {
3527 result: std::ptr::null_mut(),
3533 pub extern "C" fn CResult_NoneAPIErrorZ_err(e: crate::util::errors::APIError) -> CResult_NoneAPIErrorZ {
3534 CResult_NoneAPIErrorZ {
3535 contents: CResult_NoneAPIErrorZPtr {
3536 err: Box::into_raw(Box::new(e)),
3542 pub extern "C" fn CResult_NoneAPIErrorZ_free(_res: CResult_NoneAPIErrorZ) { }
3543 impl Drop for CResult_NoneAPIErrorZ {
3544 fn drop(&mut self) {
3547 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3548 let _ = unsafe { Box::from_raw(self.contents.err) };
3553 impl From<crate::c_types::CResultTempl<u8, crate::util::errors::APIError>> for CResult_NoneAPIErrorZ {
3554 fn from(mut o: crate::c_types::CResultTempl<u8, crate::util::errors::APIError>) -> Self {
3555 let contents = if o.result_ok {
3556 let _ = unsafe { Box::from_raw(o.contents.result) };
3557 o.contents.result = std::ptr::null_mut();
3558 CResult_NoneAPIErrorZPtr { result: std::ptr::null_mut() }
3560 let err = unsafe { o.contents.err };
3561 unsafe { o.contents.err = std::ptr::null_mut(); }
3562 CResult_NoneAPIErrorZPtr { err }
3566 result_ok: o.result_ok,
3570 impl Clone for CResult_NoneAPIErrorZ {
3571 fn clone(&self) -> Self {
3573 Self { result_ok: true, contents: CResult_NoneAPIErrorZPtr {
3574 result: std::ptr::null_mut()
3577 Self { result_ok: false, contents: CResult_NoneAPIErrorZPtr {
3578 err: Box::into_raw(Box::new(<crate::util::errors::APIError>::clone(unsafe { &*self.contents.err })))
3584 pub extern "C" fn CResult_NoneAPIErrorZ_clone(orig: &CResult_NoneAPIErrorZ) -> CResult_NoneAPIErrorZ { orig.clone() }
3586 pub struct CVec_CResult_NoneAPIErrorZZ {
3587 pub data: *mut crate::c_types::derived::CResult_NoneAPIErrorZ,
3590 impl CVec_CResult_NoneAPIErrorZZ {
3591 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CResult_NoneAPIErrorZ> {
3592 if self.datalen == 0 { return Vec::new(); }
3593 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3594 self.data = std::ptr::null_mut();
3598 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CResult_NoneAPIErrorZ] {
3599 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3602 impl From<Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>> for CVec_CResult_NoneAPIErrorZZ {
3603 fn from(v: Vec<crate::c_types::derived::CResult_NoneAPIErrorZ>) -> Self {
3604 let datalen = v.len();
3605 let data = Box::into_raw(v.into_boxed_slice());
3606 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3610 pub extern "C" fn CVec_CResult_NoneAPIErrorZZ_free(_res: CVec_CResult_NoneAPIErrorZZ) { }
3611 impl Drop for CVec_CResult_NoneAPIErrorZZ {
3612 fn drop(&mut self) {
3613 if self.datalen == 0 { return; }
3614 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3617 impl Clone for CVec_CResult_NoneAPIErrorZZ {
3618 fn clone(&self) -> Self {
3619 let mut res = Vec::new();
3620 if self.datalen == 0 { return Self::from(res); }
3621 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3626 pub struct CVec_APIErrorZ {
3627 pub data: *mut crate::util::errors::APIError,
3630 impl CVec_APIErrorZ {
3631 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::util::errors::APIError> {
3632 if self.datalen == 0 { return Vec::new(); }
3633 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3634 self.data = std::ptr::null_mut();
3638 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::util::errors::APIError] {
3639 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3642 impl From<Vec<crate::util::errors::APIError>> for CVec_APIErrorZ {
3643 fn from(v: Vec<crate::util::errors::APIError>) -> Self {
3644 let datalen = v.len();
3645 let data = Box::into_raw(v.into_boxed_slice());
3646 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3650 pub extern "C" fn CVec_APIErrorZ_free(_res: CVec_APIErrorZ) { }
3651 impl Drop for CVec_APIErrorZ {
3652 fn drop(&mut self) {
3653 if self.datalen == 0 { return; }
3654 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3657 impl Clone for CVec_APIErrorZ {
3658 fn clone(&self) -> Self {
3659 let mut res = Vec::new();
3660 if self.datalen == 0 { return Self::from(res); }
3661 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3666 pub struct CVec_ChannelDetailsZ {
3667 pub data: *mut crate::ln::channelmanager::ChannelDetails,
3670 impl CVec_ChannelDetailsZ {
3671 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::channelmanager::ChannelDetails> {
3672 if self.datalen == 0 { return Vec::new(); }
3673 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3674 self.data = std::ptr::null_mut();
3678 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::channelmanager::ChannelDetails] {
3679 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3682 impl From<Vec<crate::ln::channelmanager::ChannelDetails>> for CVec_ChannelDetailsZ {
3683 fn from(v: Vec<crate::ln::channelmanager::ChannelDetails>) -> Self {
3684 let datalen = v.len();
3685 let data = Box::into_raw(v.into_boxed_slice());
3686 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3690 pub extern "C" fn CVec_ChannelDetailsZ_free(_res: CVec_ChannelDetailsZ) { }
3691 impl Drop for CVec_ChannelDetailsZ {
3692 fn drop(&mut self) {
3693 if self.datalen == 0 { return; }
3694 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3697 impl Clone for CVec_ChannelDetailsZ {
3698 fn clone(&self) -> Self {
3699 let mut res = Vec::new();
3700 if self.datalen == 0 { return Self::from(res); }
3701 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
3706 pub union CResult_NonePaymentSendFailureZPtr {
3707 /// Note that this value is always NULL, as there are no contents in the OK variant
3708 pub result: *mut std::ffi::c_void,
3709 pub err: *mut crate::ln::channelmanager::PaymentSendFailure,
3712 pub struct CResult_NonePaymentSendFailureZ {
3713 pub contents: CResult_NonePaymentSendFailureZPtr,
3714 pub result_ok: bool,
3717 pub extern "C" fn CResult_NonePaymentSendFailureZ_ok() -> CResult_NonePaymentSendFailureZ {
3718 CResult_NonePaymentSendFailureZ {
3719 contents: CResult_NonePaymentSendFailureZPtr {
3720 result: std::ptr::null_mut(),
3726 pub extern "C" fn CResult_NonePaymentSendFailureZ_err(e: crate::ln::channelmanager::PaymentSendFailure) -> CResult_NonePaymentSendFailureZ {
3727 CResult_NonePaymentSendFailureZ {
3728 contents: CResult_NonePaymentSendFailureZPtr {
3729 err: Box::into_raw(Box::new(e)),
3735 pub extern "C" fn CResult_NonePaymentSendFailureZ_free(_res: CResult_NonePaymentSendFailureZ) { }
3736 impl Drop for CResult_NonePaymentSendFailureZ {
3737 fn drop(&mut self) {
3740 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3741 let _ = unsafe { Box::from_raw(self.contents.err) };
3746 impl From<crate::c_types::CResultTempl<u8, crate::ln::channelmanager::PaymentSendFailure>> for CResult_NonePaymentSendFailureZ {
3747 fn from(mut o: crate::c_types::CResultTempl<u8, crate::ln::channelmanager::PaymentSendFailure>) -> Self {
3748 let contents = if o.result_ok {
3749 let _ = unsafe { Box::from_raw(o.contents.result) };
3750 o.contents.result = std::ptr::null_mut();
3751 CResult_NonePaymentSendFailureZPtr { result: std::ptr::null_mut() }
3753 let err = unsafe { o.contents.err };
3754 unsafe { o.contents.err = std::ptr::null_mut(); }
3755 CResult_NonePaymentSendFailureZPtr { err }
3759 result_ok: o.result_ok,
3763 impl Clone for CResult_NonePaymentSendFailureZ {
3764 fn clone(&self) -> Self {
3766 Self { result_ok: true, contents: CResult_NonePaymentSendFailureZPtr {
3767 result: std::ptr::null_mut()
3770 Self { result_ok: false, contents: CResult_NonePaymentSendFailureZPtr {
3771 err: Box::into_raw(Box::new(<crate::ln::channelmanager::PaymentSendFailure>::clone(unsafe { &*self.contents.err })))
3777 pub extern "C" fn CResult_NonePaymentSendFailureZ_clone(orig: &CResult_NonePaymentSendFailureZ) -> CResult_NonePaymentSendFailureZ { orig.clone() }
3779 pub struct CVec_ChannelMonitorZ {
3780 pub data: *mut crate::chain::channelmonitor::ChannelMonitor,
3783 impl CVec_ChannelMonitorZ {
3784 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::chain::channelmonitor::ChannelMonitor> {
3785 if self.datalen == 0 { return Vec::new(); }
3786 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
3787 self.data = std::ptr::null_mut();
3791 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::chain::channelmonitor::ChannelMonitor] {
3792 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
3795 impl From<Vec<crate::chain::channelmonitor::ChannelMonitor>> for CVec_ChannelMonitorZ {
3796 fn from(v: Vec<crate::chain::channelmonitor::ChannelMonitor>) -> Self {
3797 let datalen = v.len();
3798 let data = Box::into_raw(v.into_boxed_slice());
3799 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
3803 pub extern "C" fn CVec_ChannelMonitorZ_free(_res: CVec_ChannelMonitorZ) { }
3804 impl Drop for CVec_ChannelMonitorZ {
3805 fn drop(&mut self) {
3806 if self.datalen == 0 { return; }
3807 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
3811 pub struct C2Tuple_BlockHashChannelManagerZ {
3812 pub a: crate::c_types::ThirtyTwoBytes,
3813 pub b: crate::ln::channelmanager::ChannelManager,
3815 impl From<(crate::c_types::ThirtyTwoBytes, crate::ln::channelmanager::ChannelManager)> for C2Tuple_BlockHashChannelManagerZ {
3816 fn from (tup: (crate::c_types::ThirtyTwoBytes, crate::ln::channelmanager::ChannelManager)) -> Self {
3823 impl C2Tuple_BlockHashChannelManagerZ {
3824 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::ThirtyTwoBytes, crate::ln::channelmanager::ChannelManager) {
3829 pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_new(a: crate::c_types::ThirtyTwoBytes, b: crate::ln::channelmanager::ChannelManager) -> C2Tuple_BlockHashChannelManagerZ {
3830 C2Tuple_BlockHashChannelManagerZ { a, b, }
3834 pub extern "C" fn C2Tuple_BlockHashChannelManagerZ_free(_res: C2Tuple_BlockHashChannelManagerZ) { }
3836 pub union CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
3837 pub result: *mut crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ,
3838 pub err: *mut crate::ln::msgs::DecodeError,
3841 pub struct CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3842 pub contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr,
3843 pub result_ok: bool,
3846 pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3847 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3848 contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
3849 result: Box::into_raw(Box::new(o)),
3855 pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3856 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3857 contents: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr {
3858 err: Box::into_raw(Box::new(e)),
3864 pub extern "C" fn CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ) { }
3865 impl Drop for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3866 fn drop(&mut self) {
3868 if unsafe { !(self.contents.result as *mut ()).is_null() } {
3869 let _ = unsafe { Box::from_raw(self.contents.result) };
3872 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3873 let _ = unsafe { Box::from_raw(self.contents.err) };
3878 impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::ln::msgs::DecodeError>> for CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
3879 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_BlockHashChannelManagerZ, crate::ln::msgs::DecodeError>) -> Self {
3880 let contents = if o.result_ok {
3881 let result = unsafe { o.contents.result };
3882 unsafe { o.contents.result = std::ptr::null_mut() };
3883 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { result }
3885 let err = unsafe { o.contents.err };
3886 unsafe { o.contents.err = std::ptr::null_mut(); }
3887 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZPtr { err }
3891 result_ok: o.result_ok,
3896 pub union CResult_SpendableOutputDescriptorDecodeErrorZPtr {
3897 pub result: *mut crate::chain::keysinterface::SpendableOutputDescriptor,
3898 pub err: *mut crate::ln::msgs::DecodeError,
3901 pub struct CResult_SpendableOutputDescriptorDecodeErrorZ {
3902 pub contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr,
3903 pub result_ok: bool,
3906 pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: crate::chain::keysinterface::SpendableOutputDescriptor) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
3907 CResult_SpendableOutputDescriptorDecodeErrorZ {
3908 contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
3909 result: Box::into_raw(Box::new(o)),
3915 pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_SpendableOutputDescriptorDecodeErrorZ {
3916 CResult_SpendableOutputDescriptorDecodeErrorZ {
3917 contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
3918 err: Box::into_raw(Box::new(e)),
3924 pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: CResult_SpendableOutputDescriptorDecodeErrorZ) { }
3925 impl Drop for CResult_SpendableOutputDescriptorDecodeErrorZ {
3926 fn drop(&mut self) {
3928 if unsafe { !(self.contents.result as *mut ()).is_null() } {
3929 let _ = unsafe { Box::from_raw(self.contents.result) };
3932 if unsafe { !(self.contents.err as *mut ()).is_null() } {
3933 let _ = unsafe { Box::from_raw(self.contents.err) };
3938 impl From<crate::c_types::CResultTempl<crate::chain::keysinterface::SpendableOutputDescriptor, crate::ln::msgs::DecodeError>> for CResult_SpendableOutputDescriptorDecodeErrorZ {
3939 fn from(mut o: crate::c_types::CResultTempl<crate::chain::keysinterface::SpendableOutputDescriptor, crate::ln::msgs::DecodeError>) -> Self {
3940 let contents = if o.result_ok {
3941 let result = unsafe { o.contents.result };
3942 unsafe { o.contents.result = std::ptr::null_mut() };
3943 CResult_SpendableOutputDescriptorDecodeErrorZPtr { result }
3945 let err = unsafe { o.contents.err };
3946 unsafe { o.contents.err = std::ptr::null_mut(); }
3947 CResult_SpendableOutputDescriptorDecodeErrorZPtr { err }
3951 result_ok: o.result_ok,
3955 impl Clone for CResult_SpendableOutputDescriptorDecodeErrorZ {
3956 fn clone(&self) -> Self {
3958 Self { result_ok: true, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
3959 result: Box::into_raw(Box::new(<crate::chain::keysinterface::SpendableOutputDescriptor>::clone(unsafe { &*self.contents.result })))
3962 Self { result_ok: false, contents: CResult_SpendableOutputDescriptorDecodeErrorZPtr {
3963 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
3969 pub extern "C" fn CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: &CResult_SpendableOutputDescriptorDecodeErrorZ) -> CResult_SpendableOutputDescriptorDecodeErrorZ { orig.clone() }
3971 pub struct C2Tuple_SignatureCVec_SignatureZZ {
3972 pub a: crate::c_types::Signature,
3973 pub b: crate::c_types::derived::CVec_SignatureZ,
3975 impl From<(crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)> for C2Tuple_SignatureCVec_SignatureZZ {
3976 fn from (tup: (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ)) -> Self {
3983 impl C2Tuple_SignatureCVec_SignatureZZ {
3984 #[allow(unused)] pub(crate) fn to_rust(mut self) -> (crate::c_types::Signature, crate::c_types::derived::CVec_SignatureZ) {
3988 impl Clone for C2Tuple_SignatureCVec_SignatureZZ {
3989 fn clone(&self) -> Self {
3997 pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_clone(orig: &C2Tuple_SignatureCVec_SignatureZZ) -> C2Tuple_SignatureCVec_SignatureZZ { orig.clone() }
3999 pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_new(a: crate::c_types::Signature, b: crate::c_types::derived::CVec_SignatureZ) -> C2Tuple_SignatureCVec_SignatureZZ {
4000 C2Tuple_SignatureCVec_SignatureZZ { a, b, }
4004 pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_free(_res: C2Tuple_SignatureCVec_SignatureZZ) { }
4006 pub union CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
4007 pub result: *mut crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ,
4008 /// Note that this value is always NULL, as there are no contents in the Err variant
4009 pub err: *mut std::ffi::c_void,
4012 pub struct CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4013 pub contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr,
4014 pub result_ok: bool,
4017 pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4018 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4019 contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
4020 result: Box::into_raw(Box::new(o)),
4026 pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4027 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4028 contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
4029 err: std::ptr::null_mut(),
4035 pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) { }
4036 impl Drop for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4037 fn drop(&mut self) {
4039 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4040 let _ = unsafe { Box::from_raw(self.contents.result) };
4046 impl From<crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, u8>> for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4047 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ, u8>) -> Self {
4048 let contents = if o.result_ok {
4049 let result = unsafe { o.contents.result };
4050 unsafe { o.contents.result = std::ptr::null_mut() };
4051 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { result }
4053 let _ = unsafe { Box::from_raw(o.contents.err) };
4054 o.contents.err = std::ptr::null_mut();
4055 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr { err: std::ptr::null_mut() }
4059 result_ok: o.result_ok,
4063 impl Clone for CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
4064 fn clone(&self) -> Self {
4066 Self { result_ok: true, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
4067 result: Box::into_raw(Box::new(<crate::c_types::derived::C2Tuple_SignatureCVec_SignatureZZ>::clone(unsafe { &*self.contents.result })))
4070 Self { result_ok: false, contents: CResult_C2Tuple_SignatureCVec_SignatureZZNoneZPtr {
4071 err: std::ptr::null_mut()
4077 pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: &CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { orig.clone() }
4079 pub union CResult_SignatureNoneZPtr {
4080 pub result: *mut crate::c_types::Signature,
4081 /// Note that this value is always NULL, as there are no contents in the Err variant
4082 pub err: *mut std::ffi::c_void,
4085 pub struct CResult_SignatureNoneZ {
4086 pub contents: CResult_SignatureNoneZPtr,
4087 pub result_ok: bool,
4090 pub extern "C" fn CResult_SignatureNoneZ_ok(o: crate::c_types::Signature) -> CResult_SignatureNoneZ {
4091 CResult_SignatureNoneZ {
4092 contents: CResult_SignatureNoneZPtr {
4093 result: Box::into_raw(Box::new(o)),
4099 pub extern "C" fn CResult_SignatureNoneZ_err() -> CResult_SignatureNoneZ {
4100 CResult_SignatureNoneZ {
4101 contents: CResult_SignatureNoneZPtr {
4102 err: std::ptr::null_mut(),
4108 pub extern "C" fn CResult_SignatureNoneZ_free(_res: CResult_SignatureNoneZ) { }
4109 impl Drop for CResult_SignatureNoneZ {
4110 fn drop(&mut self) {
4112 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4113 let _ = unsafe { Box::from_raw(self.contents.result) };
4119 impl From<crate::c_types::CResultTempl<crate::c_types::Signature, u8>> for CResult_SignatureNoneZ {
4120 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Signature, u8>) -> Self {
4121 let contents = if o.result_ok {
4122 let result = unsafe { o.contents.result };
4123 unsafe { o.contents.result = std::ptr::null_mut() };
4124 CResult_SignatureNoneZPtr { result }
4126 let _ = unsafe { Box::from_raw(o.contents.err) };
4127 o.contents.err = std::ptr::null_mut();
4128 CResult_SignatureNoneZPtr { err: std::ptr::null_mut() }
4132 result_ok: o.result_ok,
4136 impl Clone for CResult_SignatureNoneZ {
4137 fn clone(&self) -> Self {
4139 Self { result_ok: true, contents: CResult_SignatureNoneZPtr {
4140 result: Box::into_raw(Box::new(<crate::c_types::Signature>::clone(unsafe { &*self.contents.result })))
4143 Self { result_ok: false, contents: CResult_SignatureNoneZPtr {
4144 err: std::ptr::null_mut()
4150 pub extern "C" fn CResult_SignatureNoneZ_clone(orig: &CResult_SignatureNoneZ) -> CResult_SignatureNoneZ { orig.clone() }
4152 pub union CResult_SignDecodeErrorZPtr {
4153 pub result: *mut crate::chain::keysinterface::Sign,
4154 pub err: *mut crate::ln::msgs::DecodeError,
4157 pub struct CResult_SignDecodeErrorZ {
4158 pub contents: CResult_SignDecodeErrorZPtr,
4159 pub result_ok: bool,
4162 pub extern "C" fn CResult_SignDecodeErrorZ_ok(o: crate::chain::keysinterface::Sign) -> CResult_SignDecodeErrorZ {
4163 CResult_SignDecodeErrorZ {
4164 contents: CResult_SignDecodeErrorZPtr {
4165 result: Box::into_raw(Box::new(o)),
4171 pub extern "C" fn CResult_SignDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_SignDecodeErrorZ {
4172 CResult_SignDecodeErrorZ {
4173 contents: CResult_SignDecodeErrorZPtr {
4174 err: Box::into_raw(Box::new(e)),
4180 pub extern "C" fn CResult_SignDecodeErrorZ_free(_res: CResult_SignDecodeErrorZ) { }
4181 impl Drop for CResult_SignDecodeErrorZ {
4182 fn drop(&mut self) {
4184 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4185 let _ = unsafe { Box::from_raw(self.contents.result) };
4188 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4189 let _ = unsafe { Box::from_raw(self.contents.err) };
4194 impl From<crate::c_types::CResultTempl<crate::chain::keysinterface::Sign, crate::ln::msgs::DecodeError>> for CResult_SignDecodeErrorZ {
4195 fn from(mut o: crate::c_types::CResultTempl<crate::chain::keysinterface::Sign, crate::ln::msgs::DecodeError>) -> Self {
4196 let contents = if o.result_ok {
4197 let result = unsafe { o.contents.result };
4198 unsafe { o.contents.result = std::ptr::null_mut() };
4199 CResult_SignDecodeErrorZPtr { result }
4201 let err = unsafe { o.contents.err };
4202 unsafe { o.contents.err = std::ptr::null_mut(); }
4203 CResult_SignDecodeErrorZPtr { err }
4207 result_ok: o.result_ok,
4211 impl Clone for CResult_SignDecodeErrorZ {
4212 fn clone(&self) -> Self {
4214 Self { result_ok: true, contents: CResult_SignDecodeErrorZPtr {
4215 result: Box::into_raw(Box::new(<crate::chain::keysinterface::Sign>::clone(unsafe { &*self.contents.result })))
4218 Self { result_ok: false, contents: CResult_SignDecodeErrorZPtr {
4219 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
4225 pub extern "C" fn CResult_SignDecodeErrorZ_clone(orig: &CResult_SignDecodeErrorZ) -> CResult_SignDecodeErrorZ { orig.clone() }
4227 pub struct CVec_CVec_u8ZZ {
4228 pub data: *mut crate::c_types::derived::CVec_u8Z,
4231 impl CVec_CVec_u8ZZ {
4232 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_u8Z> {
4233 if self.datalen == 0 { return Vec::new(); }
4234 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4235 self.data = std::ptr::null_mut();
4239 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_u8Z] {
4240 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4243 impl From<Vec<crate::c_types::derived::CVec_u8Z>> for CVec_CVec_u8ZZ {
4244 fn from(v: Vec<crate::c_types::derived::CVec_u8Z>) -> Self {
4245 let datalen = v.len();
4246 let data = Box::into_raw(v.into_boxed_slice());
4247 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4251 pub extern "C" fn CVec_CVec_u8ZZ_free(_res: CVec_CVec_u8ZZ) { }
4252 impl Drop for CVec_CVec_u8ZZ {
4253 fn drop(&mut self) {
4254 if self.datalen == 0 { return; }
4255 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4258 impl Clone for CVec_CVec_u8ZZ {
4259 fn clone(&self) -> Self {
4260 let mut res = Vec::new();
4261 if self.datalen == 0 { return Self::from(res); }
4262 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4267 pub union CResult_CVec_CVec_u8ZZNoneZPtr {
4268 pub result: *mut crate::c_types::derived::CVec_CVec_u8ZZ,
4269 /// Note that this value is always NULL, as there are no contents in the Err variant
4270 pub err: *mut std::ffi::c_void,
4273 pub struct CResult_CVec_CVec_u8ZZNoneZ {
4274 pub contents: CResult_CVec_CVec_u8ZZNoneZPtr,
4275 pub result_ok: bool,
4278 pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_ok(o: crate::c_types::derived::CVec_CVec_u8ZZ) -> CResult_CVec_CVec_u8ZZNoneZ {
4279 CResult_CVec_CVec_u8ZZNoneZ {
4280 contents: CResult_CVec_CVec_u8ZZNoneZPtr {
4281 result: Box::into_raw(Box::new(o)),
4287 pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_err() -> CResult_CVec_CVec_u8ZZNoneZ {
4288 CResult_CVec_CVec_u8ZZNoneZ {
4289 contents: CResult_CVec_CVec_u8ZZNoneZPtr {
4290 err: std::ptr::null_mut(),
4296 pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_free(_res: CResult_CVec_CVec_u8ZZNoneZ) { }
4297 impl Drop for CResult_CVec_CVec_u8ZZNoneZ {
4298 fn drop(&mut self) {
4300 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4301 let _ = unsafe { Box::from_raw(self.contents.result) };
4307 impl From<crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, u8>> for CResult_CVec_CVec_u8ZZNoneZ {
4308 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CVec_CVec_u8ZZ, u8>) -> Self {
4309 let contents = if o.result_ok {
4310 let result = unsafe { o.contents.result };
4311 unsafe { o.contents.result = std::ptr::null_mut() };
4312 CResult_CVec_CVec_u8ZZNoneZPtr { result }
4314 let _ = unsafe { Box::from_raw(o.contents.err) };
4315 o.contents.err = std::ptr::null_mut();
4316 CResult_CVec_CVec_u8ZZNoneZPtr { err: std::ptr::null_mut() }
4320 result_ok: o.result_ok,
4324 impl Clone for CResult_CVec_CVec_u8ZZNoneZ {
4325 fn clone(&self) -> Self {
4327 Self { result_ok: true, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
4328 result: Box::into_raw(Box::new(<crate::c_types::derived::CVec_CVec_u8ZZ>::clone(unsafe { &*self.contents.result })))
4331 Self { result_ok: false, contents: CResult_CVec_CVec_u8ZZNoneZPtr {
4332 err: std::ptr::null_mut()
4338 pub extern "C" fn CResult_CVec_CVec_u8ZZNoneZ_clone(orig: &CResult_CVec_CVec_u8ZZNoneZ) -> CResult_CVec_CVec_u8ZZNoneZ { orig.clone() }
4340 pub union CResult_InMemorySignerDecodeErrorZPtr {
4341 pub result: *mut crate::chain::keysinterface::InMemorySigner,
4342 pub err: *mut crate::ln::msgs::DecodeError,
4345 pub struct CResult_InMemorySignerDecodeErrorZ {
4346 pub contents: CResult_InMemorySignerDecodeErrorZPtr,
4347 pub result_ok: bool,
4350 pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_ok(o: crate::chain::keysinterface::InMemorySigner) -> CResult_InMemorySignerDecodeErrorZ {
4351 CResult_InMemorySignerDecodeErrorZ {
4352 contents: CResult_InMemorySignerDecodeErrorZPtr {
4353 result: Box::into_raw(Box::new(o)),
4359 pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_InMemorySignerDecodeErrorZ {
4360 CResult_InMemorySignerDecodeErrorZ {
4361 contents: CResult_InMemorySignerDecodeErrorZPtr {
4362 err: Box::into_raw(Box::new(e)),
4368 pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_free(_res: CResult_InMemorySignerDecodeErrorZ) { }
4369 impl Drop for CResult_InMemorySignerDecodeErrorZ {
4370 fn drop(&mut self) {
4372 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4373 let _ = unsafe { Box::from_raw(self.contents.result) };
4376 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4377 let _ = unsafe { Box::from_raw(self.contents.err) };
4382 impl From<crate::c_types::CResultTempl<crate::chain::keysinterface::InMemorySigner, crate::ln::msgs::DecodeError>> for CResult_InMemorySignerDecodeErrorZ {
4383 fn from(mut o: crate::c_types::CResultTempl<crate::chain::keysinterface::InMemorySigner, crate::ln::msgs::DecodeError>) -> Self {
4384 let contents = if o.result_ok {
4385 let result = unsafe { o.contents.result };
4386 unsafe { o.contents.result = std::ptr::null_mut() };
4387 CResult_InMemorySignerDecodeErrorZPtr { result }
4389 let err = unsafe { o.contents.err };
4390 unsafe { o.contents.err = std::ptr::null_mut(); }
4391 CResult_InMemorySignerDecodeErrorZPtr { err }
4395 result_ok: o.result_ok,
4399 impl Clone for CResult_InMemorySignerDecodeErrorZ {
4400 fn clone(&self) -> Self {
4402 Self { result_ok: true, contents: CResult_InMemorySignerDecodeErrorZPtr {
4403 result: Box::into_raw(Box::new(<crate::chain::keysinterface::InMemorySigner>::clone(unsafe { &*self.contents.result })))
4406 Self { result_ok: false, contents: CResult_InMemorySignerDecodeErrorZPtr {
4407 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
4413 pub extern "C" fn CResult_InMemorySignerDecodeErrorZ_clone(orig: &CResult_InMemorySignerDecodeErrorZ) -> CResult_InMemorySignerDecodeErrorZ { orig.clone() }
4415 pub struct CVec_TxOutZ {
4416 pub data: *mut crate::c_types::TxOut,
4420 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::TxOut> {
4421 if self.datalen == 0 { return Vec::new(); }
4422 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4423 self.data = std::ptr::null_mut();
4427 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::TxOut] {
4428 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4431 impl From<Vec<crate::c_types::TxOut>> for CVec_TxOutZ {
4432 fn from(v: Vec<crate::c_types::TxOut>) -> Self {
4433 let datalen = v.len();
4434 let data = Box::into_raw(v.into_boxed_slice());
4435 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4439 pub extern "C" fn CVec_TxOutZ_free(_res: CVec_TxOutZ) { }
4440 impl Drop for CVec_TxOutZ {
4441 fn drop(&mut self) {
4442 if self.datalen == 0 { return; }
4443 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4446 impl Clone for CVec_TxOutZ {
4447 fn clone(&self) -> Self {
4448 let mut res = Vec::new();
4449 if self.datalen == 0 { return Self::from(res); }
4450 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4455 pub union CResult_TransactionNoneZPtr {
4456 pub result: *mut crate::c_types::Transaction,
4457 /// Note that this value is always NULL, as there are no contents in the Err variant
4458 pub err: *mut std::ffi::c_void,
4461 pub struct CResult_TransactionNoneZ {
4462 pub contents: CResult_TransactionNoneZPtr,
4463 pub result_ok: bool,
4466 pub extern "C" fn CResult_TransactionNoneZ_ok(o: crate::c_types::Transaction) -> CResult_TransactionNoneZ {
4467 CResult_TransactionNoneZ {
4468 contents: CResult_TransactionNoneZPtr {
4469 result: Box::into_raw(Box::new(o)),
4475 pub extern "C" fn CResult_TransactionNoneZ_err() -> CResult_TransactionNoneZ {
4476 CResult_TransactionNoneZ {
4477 contents: CResult_TransactionNoneZPtr {
4478 err: std::ptr::null_mut(),
4484 pub extern "C" fn CResult_TransactionNoneZ_free(_res: CResult_TransactionNoneZ) { }
4485 impl Drop for CResult_TransactionNoneZ {
4486 fn drop(&mut self) {
4488 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4489 let _ = unsafe { Box::from_raw(self.contents.result) };
4495 impl From<crate::c_types::CResultTempl<crate::c_types::Transaction, u8>> for CResult_TransactionNoneZ {
4496 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::Transaction, u8>) -> Self {
4497 let contents = if o.result_ok {
4498 let result = unsafe { o.contents.result };
4499 unsafe { o.contents.result = std::ptr::null_mut() };
4500 CResult_TransactionNoneZPtr { result }
4502 let _ = unsafe { Box::from_raw(o.contents.err) };
4503 o.contents.err = std::ptr::null_mut();
4504 CResult_TransactionNoneZPtr { err: std::ptr::null_mut() }
4508 result_ok: o.result_ok,
4513 pub struct CVec_RouteHopZ {
4514 pub data: *mut crate::routing::router::RouteHop,
4517 impl CVec_RouteHopZ {
4518 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::routing::router::RouteHop> {
4519 if self.datalen == 0 { return Vec::new(); }
4520 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4521 self.data = std::ptr::null_mut();
4525 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::routing::router::RouteHop] {
4526 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4529 impl From<Vec<crate::routing::router::RouteHop>> for CVec_RouteHopZ {
4530 fn from(v: Vec<crate::routing::router::RouteHop>) -> Self {
4531 let datalen = v.len();
4532 let data = Box::into_raw(v.into_boxed_slice());
4533 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4537 pub extern "C" fn CVec_RouteHopZ_free(_res: CVec_RouteHopZ) { }
4538 impl Drop for CVec_RouteHopZ {
4539 fn drop(&mut self) {
4540 if self.datalen == 0 { return; }
4541 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4544 impl Clone for CVec_RouteHopZ {
4545 fn clone(&self) -> Self {
4546 let mut res = Vec::new();
4547 if self.datalen == 0 { return Self::from(res); }
4548 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4553 pub struct CVec_CVec_RouteHopZZ {
4554 pub data: *mut crate::c_types::derived::CVec_RouteHopZ,
4557 impl CVec_CVec_RouteHopZZ {
4558 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::derived::CVec_RouteHopZ> {
4559 if self.datalen == 0 { return Vec::new(); }
4560 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4561 self.data = std::ptr::null_mut();
4565 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::derived::CVec_RouteHopZ] {
4566 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4569 impl From<Vec<crate::c_types::derived::CVec_RouteHopZ>> for CVec_CVec_RouteHopZZ {
4570 fn from(v: Vec<crate::c_types::derived::CVec_RouteHopZ>) -> Self {
4571 let datalen = v.len();
4572 let data = Box::into_raw(v.into_boxed_slice());
4573 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4577 pub extern "C" fn CVec_CVec_RouteHopZZ_free(_res: CVec_CVec_RouteHopZZ) { }
4578 impl Drop for CVec_CVec_RouteHopZZ {
4579 fn drop(&mut self) {
4580 if self.datalen == 0 { return; }
4581 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4584 impl Clone for CVec_CVec_RouteHopZZ {
4585 fn clone(&self) -> Self {
4586 let mut res = Vec::new();
4587 if self.datalen == 0 { return Self::from(res); }
4588 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4593 pub union CResult_RouteDecodeErrorZPtr {
4594 pub result: *mut crate::routing::router::Route,
4595 pub err: *mut crate::ln::msgs::DecodeError,
4598 pub struct CResult_RouteDecodeErrorZ {
4599 pub contents: CResult_RouteDecodeErrorZPtr,
4600 pub result_ok: bool,
4603 pub extern "C" fn CResult_RouteDecodeErrorZ_ok(o: crate::routing::router::Route) -> CResult_RouteDecodeErrorZ {
4604 CResult_RouteDecodeErrorZ {
4605 contents: CResult_RouteDecodeErrorZPtr {
4606 result: Box::into_raw(Box::new(o)),
4612 pub extern "C" fn CResult_RouteDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_RouteDecodeErrorZ {
4613 CResult_RouteDecodeErrorZ {
4614 contents: CResult_RouteDecodeErrorZPtr {
4615 err: Box::into_raw(Box::new(e)),
4621 pub extern "C" fn CResult_RouteDecodeErrorZ_free(_res: CResult_RouteDecodeErrorZ) { }
4622 impl Drop for CResult_RouteDecodeErrorZ {
4623 fn drop(&mut self) {
4625 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4626 let _ = unsafe { Box::from_raw(self.contents.result) };
4629 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4630 let _ = unsafe { Box::from_raw(self.contents.err) };
4635 impl From<crate::c_types::CResultTempl<crate::routing::router::Route, crate::ln::msgs::DecodeError>> for CResult_RouteDecodeErrorZ {
4636 fn from(mut o: crate::c_types::CResultTempl<crate::routing::router::Route, crate::ln::msgs::DecodeError>) -> Self {
4637 let contents = if o.result_ok {
4638 let result = unsafe { o.contents.result };
4639 unsafe { o.contents.result = std::ptr::null_mut() };
4640 CResult_RouteDecodeErrorZPtr { result }
4642 let err = unsafe { o.contents.err };
4643 unsafe { o.contents.err = std::ptr::null_mut(); }
4644 CResult_RouteDecodeErrorZPtr { err }
4648 result_ok: o.result_ok,
4652 impl Clone for CResult_RouteDecodeErrorZ {
4653 fn clone(&self) -> Self {
4655 Self { result_ok: true, contents: CResult_RouteDecodeErrorZPtr {
4656 result: Box::into_raw(Box::new(<crate::routing::router::Route>::clone(unsafe { &*self.contents.result })))
4659 Self { result_ok: false, contents: CResult_RouteDecodeErrorZPtr {
4660 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
4666 pub extern "C" fn CResult_RouteDecodeErrorZ_clone(orig: &CResult_RouteDecodeErrorZ) -> CResult_RouteDecodeErrorZ { orig.clone() }
4668 pub struct CVec_RouteHintZ {
4669 pub data: *mut crate::routing::router::RouteHint,
4672 impl CVec_RouteHintZ {
4673 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::routing::router::RouteHint> {
4674 if self.datalen == 0 { return Vec::new(); }
4675 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4676 self.data = std::ptr::null_mut();
4680 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::routing::router::RouteHint] {
4681 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4684 impl From<Vec<crate::routing::router::RouteHint>> for CVec_RouteHintZ {
4685 fn from(v: Vec<crate::routing::router::RouteHint>) -> Self {
4686 let datalen = v.len();
4687 let data = Box::into_raw(v.into_boxed_slice());
4688 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4692 pub extern "C" fn CVec_RouteHintZ_free(_res: CVec_RouteHintZ) { }
4693 impl Drop for CVec_RouteHintZ {
4694 fn drop(&mut self) {
4695 if self.datalen == 0 { return; }
4696 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4699 impl Clone for CVec_RouteHintZ {
4700 fn clone(&self) -> Self {
4701 let mut res = Vec::new();
4702 if self.datalen == 0 { return Self::from(res); }
4703 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4708 pub union CResult_RouteLightningErrorZPtr {
4709 pub result: *mut crate::routing::router::Route,
4710 pub err: *mut crate::ln::msgs::LightningError,
4713 pub struct CResult_RouteLightningErrorZ {
4714 pub contents: CResult_RouteLightningErrorZPtr,
4715 pub result_ok: bool,
4718 pub extern "C" fn CResult_RouteLightningErrorZ_ok(o: crate::routing::router::Route) -> CResult_RouteLightningErrorZ {
4719 CResult_RouteLightningErrorZ {
4720 contents: CResult_RouteLightningErrorZPtr {
4721 result: Box::into_raw(Box::new(o)),
4727 pub extern "C" fn CResult_RouteLightningErrorZ_err(e: crate::ln::msgs::LightningError) -> CResult_RouteLightningErrorZ {
4728 CResult_RouteLightningErrorZ {
4729 contents: CResult_RouteLightningErrorZPtr {
4730 err: Box::into_raw(Box::new(e)),
4736 pub extern "C" fn CResult_RouteLightningErrorZ_free(_res: CResult_RouteLightningErrorZ) { }
4737 impl Drop for CResult_RouteLightningErrorZ {
4738 fn drop(&mut self) {
4740 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4741 let _ = unsafe { Box::from_raw(self.contents.result) };
4744 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4745 let _ = unsafe { Box::from_raw(self.contents.err) };
4750 impl From<crate::c_types::CResultTempl<crate::routing::router::Route, crate::ln::msgs::LightningError>> for CResult_RouteLightningErrorZ {
4751 fn from(mut o: crate::c_types::CResultTempl<crate::routing::router::Route, crate::ln::msgs::LightningError>) -> Self {
4752 let contents = if o.result_ok {
4753 let result = unsafe { o.contents.result };
4754 unsafe { o.contents.result = std::ptr::null_mut() };
4755 CResult_RouteLightningErrorZPtr { result }
4757 let err = unsafe { o.contents.err };
4758 unsafe { o.contents.err = std::ptr::null_mut(); }
4759 CResult_RouteLightningErrorZPtr { err }
4763 result_ok: o.result_ok,
4767 impl Clone for CResult_RouteLightningErrorZ {
4768 fn clone(&self) -> Self {
4770 Self { result_ok: true, contents: CResult_RouteLightningErrorZPtr {
4771 result: Box::into_raw(Box::new(<crate::routing::router::Route>::clone(unsafe { &*self.contents.result })))
4774 Self { result_ok: false, contents: CResult_RouteLightningErrorZPtr {
4775 err: Box::into_raw(Box::new(<crate::ln::msgs::LightningError>::clone(unsafe { &*self.contents.err })))
4781 pub extern "C" fn CResult_RouteLightningErrorZ_clone(orig: &CResult_RouteLightningErrorZ) -> CResult_RouteLightningErrorZ { orig.clone() }
4783 pub union CResult_NetAddressu8ZPtr {
4784 pub result: *mut crate::ln::msgs::NetAddress,
4788 pub struct CResult_NetAddressu8Z {
4789 pub contents: CResult_NetAddressu8ZPtr,
4790 pub result_ok: bool,
4793 pub extern "C" fn CResult_NetAddressu8Z_ok(o: crate::ln::msgs::NetAddress) -> CResult_NetAddressu8Z {
4794 CResult_NetAddressu8Z {
4795 contents: CResult_NetAddressu8ZPtr {
4796 result: Box::into_raw(Box::new(o)),
4802 pub extern "C" fn CResult_NetAddressu8Z_err(e: u8) -> CResult_NetAddressu8Z {
4803 CResult_NetAddressu8Z {
4804 contents: CResult_NetAddressu8ZPtr {
4805 err: Box::into_raw(Box::new(e)),
4811 pub extern "C" fn CResult_NetAddressu8Z_free(_res: CResult_NetAddressu8Z) { }
4812 impl Drop for CResult_NetAddressu8Z {
4813 fn drop(&mut self) {
4815 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4816 let _ = unsafe { Box::from_raw(self.contents.result) };
4819 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4820 let _ = unsafe { Box::from_raw(self.contents.err) };
4825 impl From<crate::c_types::CResultTempl<crate::ln::msgs::NetAddress, u8>> for CResult_NetAddressu8Z {
4826 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::NetAddress, u8>) -> Self {
4827 let contents = if o.result_ok {
4828 let result = unsafe { o.contents.result };
4829 unsafe { o.contents.result = std::ptr::null_mut() };
4830 CResult_NetAddressu8ZPtr { result }
4832 let err = unsafe { o.contents.err };
4833 unsafe { o.contents.err = std::ptr::null_mut(); }
4834 CResult_NetAddressu8ZPtr { err }
4838 result_ok: o.result_ok,
4842 impl Clone for CResult_NetAddressu8Z {
4843 fn clone(&self) -> Self {
4845 Self { result_ok: true, contents: CResult_NetAddressu8ZPtr {
4846 result: Box::into_raw(Box::new(<crate::ln::msgs::NetAddress>::clone(unsafe { &*self.contents.result })))
4849 Self { result_ok: false, contents: CResult_NetAddressu8ZPtr {
4850 err: Box::into_raw(Box::new(<u8>::clone(unsafe { &*self.contents.err })))
4856 pub extern "C" fn CResult_NetAddressu8Z_clone(orig: &CResult_NetAddressu8Z) -> CResult_NetAddressu8Z { orig.clone() }
4858 pub union CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
4859 pub result: *mut crate::c_types::derived::CResult_NetAddressu8Z,
4860 pub err: *mut crate::ln::msgs::DecodeError,
4863 pub struct CResult_CResult_NetAddressu8ZDecodeErrorZ {
4864 pub contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr,
4865 pub result_ok: bool,
4868 pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o: crate::c_types::derived::CResult_NetAddressu8Z) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
4869 CResult_CResult_NetAddressu8ZDecodeErrorZ {
4870 contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
4871 result: Box::into_raw(Box::new(o)),
4877 pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_CResult_NetAddressu8ZDecodeErrorZ {
4878 CResult_CResult_NetAddressu8ZDecodeErrorZ {
4879 contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
4880 err: Box::into_raw(Box::new(e)),
4886 pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res: CResult_CResult_NetAddressu8ZDecodeErrorZ) { }
4887 impl Drop for CResult_CResult_NetAddressu8ZDecodeErrorZ {
4888 fn drop(&mut self) {
4890 if unsafe { !(self.contents.result as *mut ()).is_null() } {
4891 let _ = unsafe { Box::from_raw(self.contents.result) };
4894 if unsafe { !(self.contents.err as *mut ()).is_null() } {
4895 let _ = unsafe { Box::from_raw(self.contents.err) };
4900 impl From<crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::ln::msgs::DecodeError>> for CResult_CResult_NetAddressu8ZDecodeErrorZ {
4901 fn from(mut o: crate::c_types::CResultTempl<crate::c_types::derived::CResult_NetAddressu8Z, crate::ln::msgs::DecodeError>) -> Self {
4902 let contents = if o.result_ok {
4903 let result = unsafe { o.contents.result };
4904 unsafe { o.contents.result = std::ptr::null_mut() };
4905 CResult_CResult_NetAddressu8ZDecodeErrorZPtr { result }
4907 let err = unsafe { o.contents.err };
4908 unsafe { o.contents.err = std::ptr::null_mut(); }
4909 CResult_CResult_NetAddressu8ZDecodeErrorZPtr { err }
4913 result_ok: o.result_ok,
4917 impl Clone for CResult_CResult_NetAddressu8ZDecodeErrorZ {
4918 fn clone(&self) -> Self {
4920 Self { result_ok: true, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
4921 result: Box::into_raw(Box::new(<crate::c_types::derived::CResult_NetAddressu8Z>::clone(unsafe { &*self.contents.result })))
4924 Self { result_ok: false, contents: CResult_CResult_NetAddressu8ZDecodeErrorZPtr {
4925 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
4931 pub extern "C" fn CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig: &CResult_CResult_NetAddressu8ZDecodeErrorZ) -> CResult_CResult_NetAddressu8ZDecodeErrorZ { orig.clone() }
4933 pub struct CVec_UpdateAddHTLCZ {
4934 pub data: *mut crate::ln::msgs::UpdateAddHTLC,
4937 impl CVec_UpdateAddHTLCZ {
4938 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::UpdateAddHTLC> {
4939 if self.datalen == 0 { return Vec::new(); }
4940 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4941 self.data = std::ptr::null_mut();
4945 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::UpdateAddHTLC] {
4946 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4949 impl From<Vec<crate::ln::msgs::UpdateAddHTLC>> for CVec_UpdateAddHTLCZ {
4950 fn from(v: Vec<crate::ln::msgs::UpdateAddHTLC>) -> Self {
4951 let datalen = v.len();
4952 let data = Box::into_raw(v.into_boxed_slice());
4953 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4957 pub extern "C" fn CVec_UpdateAddHTLCZ_free(_res: CVec_UpdateAddHTLCZ) { }
4958 impl Drop for CVec_UpdateAddHTLCZ {
4959 fn drop(&mut self) {
4960 if self.datalen == 0 { return; }
4961 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
4964 impl Clone for CVec_UpdateAddHTLCZ {
4965 fn clone(&self) -> Self {
4966 let mut res = Vec::new();
4967 if self.datalen == 0 { return Self::from(res); }
4968 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
4973 pub struct CVec_UpdateFulfillHTLCZ {
4974 pub data: *mut crate::ln::msgs::UpdateFulfillHTLC,
4977 impl CVec_UpdateFulfillHTLCZ {
4978 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::UpdateFulfillHTLC> {
4979 if self.datalen == 0 { return Vec::new(); }
4980 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
4981 self.data = std::ptr::null_mut();
4985 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::UpdateFulfillHTLC] {
4986 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
4989 impl From<Vec<crate::ln::msgs::UpdateFulfillHTLC>> for CVec_UpdateFulfillHTLCZ {
4990 fn from(v: Vec<crate::ln::msgs::UpdateFulfillHTLC>) -> Self {
4991 let datalen = v.len();
4992 let data = Box::into_raw(v.into_boxed_slice());
4993 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
4997 pub extern "C" fn CVec_UpdateFulfillHTLCZ_free(_res: CVec_UpdateFulfillHTLCZ) { }
4998 impl Drop for CVec_UpdateFulfillHTLCZ {
4999 fn drop(&mut self) {
5000 if self.datalen == 0 { return; }
5001 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
5004 impl Clone for CVec_UpdateFulfillHTLCZ {
5005 fn clone(&self) -> Self {
5006 let mut res = Vec::new();
5007 if self.datalen == 0 { return Self::from(res); }
5008 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
5013 pub struct CVec_UpdateFailHTLCZ {
5014 pub data: *mut crate::ln::msgs::UpdateFailHTLC,
5017 impl CVec_UpdateFailHTLCZ {
5018 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::UpdateFailHTLC> {
5019 if self.datalen == 0 { return Vec::new(); }
5020 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
5021 self.data = std::ptr::null_mut();
5025 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::UpdateFailHTLC] {
5026 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
5029 impl From<Vec<crate::ln::msgs::UpdateFailHTLC>> for CVec_UpdateFailHTLCZ {
5030 fn from(v: Vec<crate::ln::msgs::UpdateFailHTLC>) -> Self {
5031 let datalen = v.len();
5032 let data = Box::into_raw(v.into_boxed_slice());
5033 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
5037 pub extern "C" fn CVec_UpdateFailHTLCZ_free(_res: CVec_UpdateFailHTLCZ) { }
5038 impl Drop for CVec_UpdateFailHTLCZ {
5039 fn drop(&mut self) {
5040 if self.datalen == 0 { return; }
5041 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
5044 impl Clone for CVec_UpdateFailHTLCZ {
5045 fn clone(&self) -> Self {
5046 let mut res = Vec::new();
5047 if self.datalen == 0 { return Self::from(res); }
5048 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
5053 pub struct CVec_UpdateFailMalformedHTLCZ {
5054 pub data: *mut crate::ln::msgs::UpdateFailMalformedHTLC,
5057 impl CVec_UpdateFailMalformedHTLCZ {
5058 #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::ln::msgs::UpdateFailMalformedHTLC> {
5059 if self.datalen == 0 { return Vec::new(); }
5060 let ret = unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
5061 self.data = std::ptr::null_mut();
5065 #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::ln::msgs::UpdateFailMalformedHTLC] {
5066 unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) }
5069 impl From<Vec<crate::ln::msgs::UpdateFailMalformedHTLC>> for CVec_UpdateFailMalformedHTLCZ {
5070 fn from(v: Vec<crate::ln::msgs::UpdateFailMalformedHTLC>) -> Self {
5071 let datalen = v.len();
5072 let data = Box::into_raw(v.into_boxed_slice());
5073 Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
5077 pub extern "C" fn CVec_UpdateFailMalformedHTLCZ_free(_res: CVec_UpdateFailMalformedHTLCZ) { }
5078 impl Drop for CVec_UpdateFailMalformedHTLCZ {
5079 fn drop(&mut self) {
5080 if self.datalen == 0 { return; }
5081 unsafe { Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) };
5084 impl Clone for CVec_UpdateFailMalformedHTLCZ {
5085 fn clone(&self) -> Self {
5086 let mut res = Vec::new();
5087 if self.datalen == 0 { return Self::from(res); }
5088 res.extend_from_slice(unsafe { std::slice::from_raw_parts_mut(self.data, self.datalen) });
5093 pub union CResult_AcceptChannelDecodeErrorZPtr {
5094 pub result: *mut crate::ln::msgs::AcceptChannel,
5095 pub err: *mut crate::ln::msgs::DecodeError,
5098 pub struct CResult_AcceptChannelDecodeErrorZ {
5099 pub contents: CResult_AcceptChannelDecodeErrorZPtr,
5100 pub result_ok: bool,
5103 pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_ok(o: crate::ln::msgs::AcceptChannel) -> CResult_AcceptChannelDecodeErrorZ {
5104 CResult_AcceptChannelDecodeErrorZ {
5105 contents: CResult_AcceptChannelDecodeErrorZPtr {
5106 result: Box::into_raw(Box::new(o)),
5112 pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_AcceptChannelDecodeErrorZ {
5113 CResult_AcceptChannelDecodeErrorZ {
5114 contents: CResult_AcceptChannelDecodeErrorZPtr {
5115 err: Box::into_raw(Box::new(e)),
5121 pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_free(_res: CResult_AcceptChannelDecodeErrorZ) { }
5122 impl Drop for CResult_AcceptChannelDecodeErrorZ {
5123 fn drop(&mut self) {
5125 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5126 let _ = unsafe { Box::from_raw(self.contents.result) };
5129 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5130 let _ = unsafe { Box::from_raw(self.contents.err) };
5135 impl From<crate::c_types::CResultTempl<crate::ln::msgs::AcceptChannel, crate::ln::msgs::DecodeError>> for CResult_AcceptChannelDecodeErrorZ {
5136 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::AcceptChannel, crate::ln::msgs::DecodeError>) -> Self {
5137 let contents = if o.result_ok {
5138 let result = unsafe { o.contents.result };
5139 unsafe { o.contents.result = std::ptr::null_mut() };
5140 CResult_AcceptChannelDecodeErrorZPtr { result }
5142 let err = unsafe { o.contents.err };
5143 unsafe { o.contents.err = std::ptr::null_mut(); }
5144 CResult_AcceptChannelDecodeErrorZPtr { err }
5148 result_ok: o.result_ok,
5152 impl Clone for CResult_AcceptChannelDecodeErrorZ {
5153 fn clone(&self) -> Self {
5155 Self { result_ok: true, contents: CResult_AcceptChannelDecodeErrorZPtr {
5156 result: Box::into_raw(Box::new(<crate::ln::msgs::AcceptChannel>::clone(unsafe { &*self.contents.result })))
5159 Self { result_ok: false, contents: CResult_AcceptChannelDecodeErrorZPtr {
5160 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5166 pub extern "C" fn CResult_AcceptChannelDecodeErrorZ_clone(orig: &CResult_AcceptChannelDecodeErrorZ) -> CResult_AcceptChannelDecodeErrorZ { orig.clone() }
5168 pub union CResult_AnnouncementSignaturesDecodeErrorZPtr {
5169 pub result: *mut crate::ln::msgs::AnnouncementSignatures,
5170 pub err: *mut crate::ln::msgs::DecodeError,
5173 pub struct CResult_AnnouncementSignaturesDecodeErrorZ {
5174 pub contents: CResult_AnnouncementSignaturesDecodeErrorZPtr,
5175 pub result_ok: bool,
5178 pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: crate::ln::msgs::AnnouncementSignatures) -> CResult_AnnouncementSignaturesDecodeErrorZ {
5179 CResult_AnnouncementSignaturesDecodeErrorZ {
5180 contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
5181 result: Box::into_raw(Box::new(o)),
5187 pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_AnnouncementSignaturesDecodeErrorZ {
5188 CResult_AnnouncementSignaturesDecodeErrorZ {
5189 contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
5190 err: Box::into_raw(Box::new(e)),
5196 pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: CResult_AnnouncementSignaturesDecodeErrorZ) { }
5197 impl Drop for CResult_AnnouncementSignaturesDecodeErrorZ {
5198 fn drop(&mut self) {
5200 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5201 let _ = unsafe { Box::from_raw(self.contents.result) };
5204 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5205 let _ = unsafe { Box::from_raw(self.contents.err) };
5210 impl From<crate::c_types::CResultTempl<crate::ln::msgs::AnnouncementSignatures, crate::ln::msgs::DecodeError>> for CResult_AnnouncementSignaturesDecodeErrorZ {
5211 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::AnnouncementSignatures, crate::ln::msgs::DecodeError>) -> Self {
5212 let contents = if o.result_ok {
5213 let result = unsafe { o.contents.result };
5214 unsafe { o.contents.result = std::ptr::null_mut() };
5215 CResult_AnnouncementSignaturesDecodeErrorZPtr { result }
5217 let err = unsafe { o.contents.err };
5218 unsafe { o.contents.err = std::ptr::null_mut(); }
5219 CResult_AnnouncementSignaturesDecodeErrorZPtr { err }
5223 result_ok: o.result_ok,
5227 impl Clone for CResult_AnnouncementSignaturesDecodeErrorZ {
5228 fn clone(&self) -> Self {
5230 Self { result_ok: true, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
5231 result: Box::into_raw(Box::new(<crate::ln::msgs::AnnouncementSignatures>::clone(unsafe { &*self.contents.result })))
5234 Self { result_ok: false, contents: CResult_AnnouncementSignaturesDecodeErrorZPtr {
5235 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5241 pub extern "C" fn CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: &CResult_AnnouncementSignaturesDecodeErrorZ) -> CResult_AnnouncementSignaturesDecodeErrorZ { orig.clone() }
5243 pub union CResult_ChannelReestablishDecodeErrorZPtr {
5244 pub result: *mut crate::ln::msgs::ChannelReestablish,
5245 pub err: *mut crate::ln::msgs::DecodeError,
5248 pub struct CResult_ChannelReestablishDecodeErrorZ {
5249 pub contents: CResult_ChannelReestablishDecodeErrorZPtr,
5250 pub result_ok: bool,
5253 pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_ok(o: crate::ln::msgs::ChannelReestablish) -> CResult_ChannelReestablishDecodeErrorZ {
5254 CResult_ChannelReestablishDecodeErrorZ {
5255 contents: CResult_ChannelReestablishDecodeErrorZPtr {
5256 result: Box::into_raw(Box::new(o)),
5262 pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelReestablishDecodeErrorZ {
5263 CResult_ChannelReestablishDecodeErrorZ {
5264 contents: CResult_ChannelReestablishDecodeErrorZPtr {
5265 err: Box::into_raw(Box::new(e)),
5271 pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_free(_res: CResult_ChannelReestablishDecodeErrorZ) { }
5272 impl Drop for CResult_ChannelReestablishDecodeErrorZ {
5273 fn drop(&mut self) {
5275 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5276 let _ = unsafe { Box::from_raw(self.contents.result) };
5279 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5280 let _ = unsafe { Box::from_raw(self.contents.err) };
5285 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ChannelReestablish, crate::ln::msgs::DecodeError>> for CResult_ChannelReestablishDecodeErrorZ {
5286 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ChannelReestablish, crate::ln::msgs::DecodeError>) -> Self {
5287 let contents = if o.result_ok {
5288 let result = unsafe { o.contents.result };
5289 unsafe { o.contents.result = std::ptr::null_mut() };
5290 CResult_ChannelReestablishDecodeErrorZPtr { result }
5292 let err = unsafe { o.contents.err };
5293 unsafe { o.contents.err = std::ptr::null_mut(); }
5294 CResult_ChannelReestablishDecodeErrorZPtr { err }
5298 result_ok: o.result_ok,
5302 impl Clone for CResult_ChannelReestablishDecodeErrorZ {
5303 fn clone(&self) -> Self {
5305 Self { result_ok: true, contents: CResult_ChannelReestablishDecodeErrorZPtr {
5306 result: Box::into_raw(Box::new(<crate::ln::msgs::ChannelReestablish>::clone(unsafe { &*self.contents.result })))
5309 Self { result_ok: false, contents: CResult_ChannelReestablishDecodeErrorZPtr {
5310 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5316 pub extern "C" fn CResult_ChannelReestablishDecodeErrorZ_clone(orig: &CResult_ChannelReestablishDecodeErrorZ) -> CResult_ChannelReestablishDecodeErrorZ { orig.clone() }
5318 pub union CResult_ClosingSignedDecodeErrorZPtr {
5319 pub result: *mut crate::ln::msgs::ClosingSigned,
5320 pub err: *mut crate::ln::msgs::DecodeError,
5323 pub struct CResult_ClosingSignedDecodeErrorZ {
5324 pub contents: CResult_ClosingSignedDecodeErrorZPtr,
5325 pub result_ok: bool,
5328 pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_ok(o: crate::ln::msgs::ClosingSigned) -> CResult_ClosingSignedDecodeErrorZ {
5329 CResult_ClosingSignedDecodeErrorZ {
5330 contents: CResult_ClosingSignedDecodeErrorZPtr {
5331 result: Box::into_raw(Box::new(o)),
5337 pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ClosingSignedDecodeErrorZ {
5338 CResult_ClosingSignedDecodeErrorZ {
5339 contents: CResult_ClosingSignedDecodeErrorZPtr {
5340 err: Box::into_raw(Box::new(e)),
5346 pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_free(_res: CResult_ClosingSignedDecodeErrorZ) { }
5347 impl Drop for CResult_ClosingSignedDecodeErrorZ {
5348 fn drop(&mut self) {
5350 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5351 let _ = unsafe { Box::from_raw(self.contents.result) };
5354 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5355 let _ = unsafe { Box::from_raw(self.contents.err) };
5360 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ClosingSigned, crate::ln::msgs::DecodeError>> for CResult_ClosingSignedDecodeErrorZ {
5361 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ClosingSigned, crate::ln::msgs::DecodeError>) -> Self {
5362 let contents = if o.result_ok {
5363 let result = unsafe { o.contents.result };
5364 unsafe { o.contents.result = std::ptr::null_mut() };
5365 CResult_ClosingSignedDecodeErrorZPtr { result }
5367 let err = unsafe { o.contents.err };
5368 unsafe { o.contents.err = std::ptr::null_mut(); }
5369 CResult_ClosingSignedDecodeErrorZPtr { err }
5373 result_ok: o.result_ok,
5377 impl Clone for CResult_ClosingSignedDecodeErrorZ {
5378 fn clone(&self) -> Self {
5380 Self { result_ok: true, contents: CResult_ClosingSignedDecodeErrorZPtr {
5381 result: Box::into_raw(Box::new(<crate::ln::msgs::ClosingSigned>::clone(unsafe { &*self.contents.result })))
5384 Self { result_ok: false, contents: CResult_ClosingSignedDecodeErrorZPtr {
5385 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5391 pub extern "C" fn CResult_ClosingSignedDecodeErrorZ_clone(orig: &CResult_ClosingSignedDecodeErrorZ) -> CResult_ClosingSignedDecodeErrorZ { orig.clone() }
5393 pub union CResult_CommitmentSignedDecodeErrorZPtr {
5394 pub result: *mut crate::ln::msgs::CommitmentSigned,
5395 pub err: *mut crate::ln::msgs::DecodeError,
5398 pub struct CResult_CommitmentSignedDecodeErrorZ {
5399 pub contents: CResult_CommitmentSignedDecodeErrorZPtr,
5400 pub result_ok: bool,
5403 pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_ok(o: crate::ln::msgs::CommitmentSigned) -> CResult_CommitmentSignedDecodeErrorZ {
5404 CResult_CommitmentSignedDecodeErrorZ {
5405 contents: CResult_CommitmentSignedDecodeErrorZPtr {
5406 result: Box::into_raw(Box::new(o)),
5412 pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_CommitmentSignedDecodeErrorZ {
5413 CResult_CommitmentSignedDecodeErrorZ {
5414 contents: CResult_CommitmentSignedDecodeErrorZPtr {
5415 err: Box::into_raw(Box::new(e)),
5421 pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_free(_res: CResult_CommitmentSignedDecodeErrorZ) { }
5422 impl Drop for CResult_CommitmentSignedDecodeErrorZ {
5423 fn drop(&mut self) {
5425 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5426 let _ = unsafe { Box::from_raw(self.contents.result) };
5429 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5430 let _ = unsafe { Box::from_raw(self.contents.err) };
5435 impl From<crate::c_types::CResultTempl<crate::ln::msgs::CommitmentSigned, crate::ln::msgs::DecodeError>> for CResult_CommitmentSignedDecodeErrorZ {
5436 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::CommitmentSigned, crate::ln::msgs::DecodeError>) -> Self {
5437 let contents = if o.result_ok {
5438 let result = unsafe { o.contents.result };
5439 unsafe { o.contents.result = std::ptr::null_mut() };
5440 CResult_CommitmentSignedDecodeErrorZPtr { result }
5442 let err = unsafe { o.contents.err };
5443 unsafe { o.contents.err = std::ptr::null_mut(); }
5444 CResult_CommitmentSignedDecodeErrorZPtr { err }
5448 result_ok: o.result_ok,
5452 impl Clone for CResult_CommitmentSignedDecodeErrorZ {
5453 fn clone(&self) -> Self {
5455 Self { result_ok: true, contents: CResult_CommitmentSignedDecodeErrorZPtr {
5456 result: Box::into_raw(Box::new(<crate::ln::msgs::CommitmentSigned>::clone(unsafe { &*self.contents.result })))
5459 Self { result_ok: false, contents: CResult_CommitmentSignedDecodeErrorZPtr {
5460 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5466 pub extern "C" fn CResult_CommitmentSignedDecodeErrorZ_clone(orig: &CResult_CommitmentSignedDecodeErrorZ) -> CResult_CommitmentSignedDecodeErrorZ { orig.clone() }
5468 pub union CResult_FundingCreatedDecodeErrorZPtr {
5469 pub result: *mut crate::ln::msgs::FundingCreated,
5470 pub err: *mut crate::ln::msgs::DecodeError,
5473 pub struct CResult_FundingCreatedDecodeErrorZ {
5474 pub contents: CResult_FundingCreatedDecodeErrorZPtr,
5475 pub result_ok: bool,
5478 pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_ok(o: crate::ln::msgs::FundingCreated) -> CResult_FundingCreatedDecodeErrorZ {
5479 CResult_FundingCreatedDecodeErrorZ {
5480 contents: CResult_FundingCreatedDecodeErrorZPtr {
5481 result: Box::into_raw(Box::new(o)),
5487 pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_FundingCreatedDecodeErrorZ {
5488 CResult_FundingCreatedDecodeErrorZ {
5489 contents: CResult_FundingCreatedDecodeErrorZPtr {
5490 err: Box::into_raw(Box::new(e)),
5496 pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_free(_res: CResult_FundingCreatedDecodeErrorZ) { }
5497 impl Drop for CResult_FundingCreatedDecodeErrorZ {
5498 fn drop(&mut self) {
5500 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5501 let _ = unsafe { Box::from_raw(self.contents.result) };
5504 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5505 let _ = unsafe { Box::from_raw(self.contents.err) };
5510 impl From<crate::c_types::CResultTempl<crate::ln::msgs::FundingCreated, crate::ln::msgs::DecodeError>> for CResult_FundingCreatedDecodeErrorZ {
5511 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::FundingCreated, crate::ln::msgs::DecodeError>) -> Self {
5512 let contents = if o.result_ok {
5513 let result = unsafe { o.contents.result };
5514 unsafe { o.contents.result = std::ptr::null_mut() };
5515 CResult_FundingCreatedDecodeErrorZPtr { result }
5517 let err = unsafe { o.contents.err };
5518 unsafe { o.contents.err = std::ptr::null_mut(); }
5519 CResult_FundingCreatedDecodeErrorZPtr { err }
5523 result_ok: o.result_ok,
5527 impl Clone for CResult_FundingCreatedDecodeErrorZ {
5528 fn clone(&self) -> Self {
5530 Self { result_ok: true, contents: CResult_FundingCreatedDecodeErrorZPtr {
5531 result: Box::into_raw(Box::new(<crate::ln::msgs::FundingCreated>::clone(unsafe { &*self.contents.result })))
5534 Self { result_ok: false, contents: CResult_FundingCreatedDecodeErrorZPtr {
5535 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5541 pub extern "C" fn CResult_FundingCreatedDecodeErrorZ_clone(orig: &CResult_FundingCreatedDecodeErrorZ) -> CResult_FundingCreatedDecodeErrorZ { orig.clone() }
5543 pub union CResult_FundingSignedDecodeErrorZPtr {
5544 pub result: *mut crate::ln::msgs::FundingSigned,
5545 pub err: *mut crate::ln::msgs::DecodeError,
5548 pub struct CResult_FundingSignedDecodeErrorZ {
5549 pub contents: CResult_FundingSignedDecodeErrorZPtr,
5550 pub result_ok: bool,
5553 pub extern "C" fn CResult_FundingSignedDecodeErrorZ_ok(o: crate::ln::msgs::FundingSigned) -> CResult_FundingSignedDecodeErrorZ {
5554 CResult_FundingSignedDecodeErrorZ {
5555 contents: CResult_FundingSignedDecodeErrorZPtr {
5556 result: Box::into_raw(Box::new(o)),
5562 pub extern "C" fn CResult_FundingSignedDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_FundingSignedDecodeErrorZ {
5563 CResult_FundingSignedDecodeErrorZ {
5564 contents: CResult_FundingSignedDecodeErrorZPtr {
5565 err: Box::into_raw(Box::new(e)),
5571 pub extern "C" fn CResult_FundingSignedDecodeErrorZ_free(_res: CResult_FundingSignedDecodeErrorZ) { }
5572 impl Drop for CResult_FundingSignedDecodeErrorZ {
5573 fn drop(&mut self) {
5575 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5576 let _ = unsafe { Box::from_raw(self.contents.result) };
5579 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5580 let _ = unsafe { Box::from_raw(self.contents.err) };
5585 impl From<crate::c_types::CResultTempl<crate::ln::msgs::FundingSigned, crate::ln::msgs::DecodeError>> for CResult_FundingSignedDecodeErrorZ {
5586 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::FundingSigned, crate::ln::msgs::DecodeError>) -> Self {
5587 let contents = if o.result_ok {
5588 let result = unsafe { o.contents.result };
5589 unsafe { o.contents.result = std::ptr::null_mut() };
5590 CResult_FundingSignedDecodeErrorZPtr { result }
5592 let err = unsafe { o.contents.err };
5593 unsafe { o.contents.err = std::ptr::null_mut(); }
5594 CResult_FundingSignedDecodeErrorZPtr { err }
5598 result_ok: o.result_ok,
5602 impl Clone for CResult_FundingSignedDecodeErrorZ {
5603 fn clone(&self) -> Self {
5605 Self { result_ok: true, contents: CResult_FundingSignedDecodeErrorZPtr {
5606 result: Box::into_raw(Box::new(<crate::ln::msgs::FundingSigned>::clone(unsafe { &*self.contents.result })))
5609 Self { result_ok: false, contents: CResult_FundingSignedDecodeErrorZPtr {
5610 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5616 pub extern "C" fn CResult_FundingSignedDecodeErrorZ_clone(orig: &CResult_FundingSignedDecodeErrorZ) -> CResult_FundingSignedDecodeErrorZ { orig.clone() }
5618 pub union CResult_FundingLockedDecodeErrorZPtr {
5619 pub result: *mut crate::ln::msgs::FundingLocked,
5620 pub err: *mut crate::ln::msgs::DecodeError,
5623 pub struct CResult_FundingLockedDecodeErrorZ {
5624 pub contents: CResult_FundingLockedDecodeErrorZPtr,
5625 pub result_ok: bool,
5628 pub extern "C" fn CResult_FundingLockedDecodeErrorZ_ok(o: crate::ln::msgs::FundingLocked) -> CResult_FundingLockedDecodeErrorZ {
5629 CResult_FundingLockedDecodeErrorZ {
5630 contents: CResult_FundingLockedDecodeErrorZPtr {
5631 result: Box::into_raw(Box::new(o)),
5637 pub extern "C" fn CResult_FundingLockedDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_FundingLockedDecodeErrorZ {
5638 CResult_FundingLockedDecodeErrorZ {
5639 contents: CResult_FundingLockedDecodeErrorZPtr {
5640 err: Box::into_raw(Box::new(e)),
5646 pub extern "C" fn CResult_FundingLockedDecodeErrorZ_free(_res: CResult_FundingLockedDecodeErrorZ) { }
5647 impl Drop for CResult_FundingLockedDecodeErrorZ {
5648 fn drop(&mut self) {
5650 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5651 let _ = unsafe { Box::from_raw(self.contents.result) };
5654 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5655 let _ = unsafe { Box::from_raw(self.contents.err) };
5660 impl From<crate::c_types::CResultTempl<crate::ln::msgs::FundingLocked, crate::ln::msgs::DecodeError>> for CResult_FundingLockedDecodeErrorZ {
5661 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::FundingLocked, crate::ln::msgs::DecodeError>) -> Self {
5662 let contents = if o.result_ok {
5663 let result = unsafe { o.contents.result };
5664 unsafe { o.contents.result = std::ptr::null_mut() };
5665 CResult_FundingLockedDecodeErrorZPtr { result }
5667 let err = unsafe { o.contents.err };
5668 unsafe { o.contents.err = std::ptr::null_mut(); }
5669 CResult_FundingLockedDecodeErrorZPtr { err }
5673 result_ok: o.result_ok,
5677 impl Clone for CResult_FundingLockedDecodeErrorZ {
5678 fn clone(&self) -> Self {
5680 Self { result_ok: true, contents: CResult_FundingLockedDecodeErrorZPtr {
5681 result: Box::into_raw(Box::new(<crate::ln::msgs::FundingLocked>::clone(unsafe { &*self.contents.result })))
5684 Self { result_ok: false, contents: CResult_FundingLockedDecodeErrorZPtr {
5685 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5691 pub extern "C" fn CResult_FundingLockedDecodeErrorZ_clone(orig: &CResult_FundingLockedDecodeErrorZ) -> CResult_FundingLockedDecodeErrorZ { orig.clone() }
5693 pub union CResult_InitDecodeErrorZPtr {
5694 pub result: *mut crate::ln::msgs::Init,
5695 pub err: *mut crate::ln::msgs::DecodeError,
5698 pub struct CResult_InitDecodeErrorZ {
5699 pub contents: CResult_InitDecodeErrorZPtr,
5700 pub result_ok: bool,
5703 pub extern "C" fn CResult_InitDecodeErrorZ_ok(o: crate::ln::msgs::Init) -> CResult_InitDecodeErrorZ {
5704 CResult_InitDecodeErrorZ {
5705 contents: CResult_InitDecodeErrorZPtr {
5706 result: Box::into_raw(Box::new(o)),
5712 pub extern "C" fn CResult_InitDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_InitDecodeErrorZ {
5713 CResult_InitDecodeErrorZ {
5714 contents: CResult_InitDecodeErrorZPtr {
5715 err: Box::into_raw(Box::new(e)),
5721 pub extern "C" fn CResult_InitDecodeErrorZ_free(_res: CResult_InitDecodeErrorZ) { }
5722 impl Drop for CResult_InitDecodeErrorZ {
5723 fn drop(&mut self) {
5725 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5726 let _ = unsafe { Box::from_raw(self.contents.result) };
5729 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5730 let _ = unsafe { Box::from_raw(self.contents.err) };
5735 impl From<crate::c_types::CResultTempl<crate::ln::msgs::Init, crate::ln::msgs::DecodeError>> for CResult_InitDecodeErrorZ {
5736 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::Init, crate::ln::msgs::DecodeError>) -> Self {
5737 let contents = if o.result_ok {
5738 let result = unsafe { o.contents.result };
5739 unsafe { o.contents.result = std::ptr::null_mut() };
5740 CResult_InitDecodeErrorZPtr { result }
5742 let err = unsafe { o.contents.err };
5743 unsafe { o.contents.err = std::ptr::null_mut(); }
5744 CResult_InitDecodeErrorZPtr { err }
5748 result_ok: o.result_ok,
5752 impl Clone for CResult_InitDecodeErrorZ {
5753 fn clone(&self) -> Self {
5755 Self { result_ok: true, contents: CResult_InitDecodeErrorZPtr {
5756 result: Box::into_raw(Box::new(<crate::ln::msgs::Init>::clone(unsafe { &*self.contents.result })))
5759 Self { result_ok: false, contents: CResult_InitDecodeErrorZPtr {
5760 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5766 pub extern "C" fn CResult_InitDecodeErrorZ_clone(orig: &CResult_InitDecodeErrorZ) -> CResult_InitDecodeErrorZ { orig.clone() }
5768 pub union CResult_OpenChannelDecodeErrorZPtr {
5769 pub result: *mut crate::ln::msgs::OpenChannel,
5770 pub err: *mut crate::ln::msgs::DecodeError,
5773 pub struct CResult_OpenChannelDecodeErrorZ {
5774 pub contents: CResult_OpenChannelDecodeErrorZPtr,
5775 pub result_ok: bool,
5778 pub extern "C" fn CResult_OpenChannelDecodeErrorZ_ok(o: crate::ln::msgs::OpenChannel) -> CResult_OpenChannelDecodeErrorZ {
5779 CResult_OpenChannelDecodeErrorZ {
5780 contents: CResult_OpenChannelDecodeErrorZPtr {
5781 result: Box::into_raw(Box::new(o)),
5787 pub extern "C" fn CResult_OpenChannelDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_OpenChannelDecodeErrorZ {
5788 CResult_OpenChannelDecodeErrorZ {
5789 contents: CResult_OpenChannelDecodeErrorZPtr {
5790 err: Box::into_raw(Box::new(e)),
5796 pub extern "C" fn CResult_OpenChannelDecodeErrorZ_free(_res: CResult_OpenChannelDecodeErrorZ) { }
5797 impl Drop for CResult_OpenChannelDecodeErrorZ {
5798 fn drop(&mut self) {
5800 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5801 let _ = unsafe { Box::from_raw(self.contents.result) };
5804 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5805 let _ = unsafe { Box::from_raw(self.contents.err) };
5810 impl From<crate::c_types::CResultTempl<crate::ln::msgs::OpenChannel, crate::ln::msgs::DecodeError>> for CResult_OpenChannelDecodeErrorZ {
5811 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::OpenChannel, crate::ln::msgs::DecodeError>) -> Self {
5812 let contents = if o.result_ok {
5813 let result = unsafe { o.contents.result };
5814 unsafe { o.contents.result = std::ptr::null_mut() };
5815 CResult_OpenChannelDecodeErrorZPtr { result }
5817 let err = unsafe { o.contents.err };
5818 unsafe { o.contents.err = std::ptr::null_mut(); }
5819 CResult_OpenChannelDecodeErrorZPtr { err }
5823 result_ok: o.result_ok,
5827 impl Clone for CResult_OpenChannelDecodeErrorZ {
5828 fn clone(&self) -> Self {
5830 Self { result_ok: true, contents: CResult_OpenChannelDecodeErrorZPtr {
5831 result: Box::into_raw(Box::new(<crate::ln::msgs::OpenChannel>::clone(unsafe { &*self.contents.result })))
5834 Self { result_ok: false, contents: CResult_OpenChannelDecodeErrorZPtr {
5835 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5841 pub extern "C" fn CResult_OpenChannelDecodeErrorZ_clone(orig: &CResult_OpenChannelDecodeErrorZ) -> CResult_OpenChannelDecodeErrorZ { orig.clone() }
5843 pub union CResult_RevokeAndACKDecodeErrorZPtr {
5844 pub result: *mut crate::ln::msgs::RevokeAndACK,
5845 pub err: *mut crate::ln::msgs::DecodeError,
5848 pub struct CResult_RevokeAndACKDecodeErrorZ {
5849 pub contents: CResult_RevokeAndACKDecodeErrorZPtr,
5850 pub result_ok: bool,
5853 pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_ok(o: crate::ln::msgs::RevokeAndACK) -> CResult_RevokeAndACKDecodeErrorZ {
5854 CResult_RevokeAndACKDecodeErrorZ {
5855 contents: CResult_RevokeAndACKDecodeErrorZPtr {
5856 result: Box::into_raw(Box::new(o)),
5862 pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_RevokeAndACKDecodeErrorZ {
5863 CResult_RevokeAndACKDecodeErrorZ {
5864 contents: CResult_RevokeAndACKDecodeErrorZPtr {
5865 err: Box::into_raw(Box::new(e)),
5871 pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_free(_res: CResult_RevokeAndACKDecodeErrorZ) { }
5872 impl Drop for CResult_RevokeAndACKDecodeErrorZ {
5873 fn drop(&mut self) {
5875 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5876 let _ = unsafe { Box::from_raw(self.contents.result) };
5879 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5880 let _ = unsafe { Box::from_raw(self.contents.err) };
5885 impl From<crate::c_types::CResultTempl<crate::ln::msgs::RevokeAndACK, crate::ln::msgs::DecodeError>> for CResult_RevokeAndACKDecodeErrorZ {
5886 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::RevokeAndACK, crate::ln::msgs::DecodeError>) -> Self {
5887 let contents = if o.result_ok {
5888 let result = unsafe { o.contents.result };
5889 unsafe { o.contents.result = std::ptr::null_mut() };
5890 CResult_RevokeAndACKDecodeErrorZPtr { result }
5892 let err = unsafe { o.contents.err };
5893 unsafe { o.contents.err = std::ptr::null_mut(); }
5894 CResult_RevokeAndACKDecodeErrorZPtr { err }
5898 result_ok: o.result_ok,
5902 impl Clone for CResult_RevokeAndACKDecodeErrorZ {
5903 fn clone(&self) -> Self {
5905 Self { result_ok: true, contents: CResult_RevokeAndACKDecodeErrorZPtr {
5906 result: Box::into_raw(Box::new(<crate::ln::msgs::RevokeAndACK>::clone(unsafe { &*self.contents.result })))
5909 Self { result_ok: false, contents: CResult_RevokeAndACKDecodeErrorZPtr {
5910 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5916 pub extern "C" fn CResult_RevokeAndACKDecodeErrorZ_clone(orig: &CResult_RevokeAndACKDecodeErrorZ) -> CResult_RevokeAndACKDecodeErrorZ { orig.clone() }
5918 pub union CResult_ShutdownDecodeErrorZPtr {
5919 pub result: *mut crate::ln::msgs::Shutdown,
5920 pub err: *mut crate::ln::msgs::DecodeError,
5923 pub struct CResult_ShutdownDecodeErrorZ {
5924 pub contents: CResult_ShutdownDecodeErrorZPtr,
5925 pub result_ok: bool,
5928 pub extern "C" fn CResult_ShutdownDecodeErrorZ_ok(o: crate::ln::msgs::Shutdown) -> CResult_ShutdownDecodeErrorZ {
5929 CResult_ShutdownDecodeErrorZ {
5930 contents: CResult_ShutdownDecodeErrorZPtr {
5931 result: Box::into_raw(Box::new(o)),
5937 pub extern "C" fn CResult_ShutdownDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ShutdownDecodeErrorZ {
5938 CResult_ShutdownDecodeErrorZ {
5939 contents: CResult_ShutdownDecodeErrorZPtr {
5940 err: Box::into_raw(Box::new(e)),
5946 pub extern "C" fn CResult_ShutdownDecodeErrorZ_free(_res: CResult_ShutdownDecodeErrorZ) { }
5947 impl Drop for CResult_ShutdownDecodeErrorZ {
5948 fn drop(&mut self) {
5950 if unsafe { !(self.contents.result as *mut ()).is_null() } {
5951 let _ = unsafe { Box::from_raw(self.contents.result) };
5954 if unsafe { !(self.contents.err as *mut ()).is_null() } {
5955 let _ = unsafe { Box::from_raw(self.contents.err) };
5960 impl From<crate::c_types::CResultTempl<crate::ln::msgs::Shutdown, crate::ln::msgs::DecodeError>> for CResult_ShutdownDecodeErrorZ {
5961 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::Shutdown, crate::ln::msgs::DecodeError>) -> Self {
5962 let contents = if o.result_ok {
5963 let result = unsafe { o.contents.result };
5964 unsafe { o.contents.result = std::ptr::null_mut() };
5965 CResult_ShutdownDecodeErrorZPtr { result }
5967 let err = unsafe { o.contents.err };
5968 unsafe { o.contents.err = std::ptr::null_mut(); }
5969 CResult_ShutdownDecodeErrorZPtr { err }
5973 result_ok: o.result_ok,
5977 impl Clone for CResult_ShutdownDecodeErrorZ {
5978 fn clone(&self) -> Self {
5980 Self { result_ok: true, contents: CResult_ShutdownDecodeErrorZPtr {
5981 result: Box::into_raw(Box::new(<crate::ln::msgs::Shutdown>::clone(unsafe { &*self.contents.result })))
5984 Self { result_ok: false, contents: CResult_ShutdownDecodeErrorZPtr {
5985 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
5991 pub extern "C" fn CResult_ShutdownDecodeErrorZ_clone(orig: &CResult_ShutdownDecodeErrorZ) -> CResult_ShutdownDecodeErrorZ { orig.clone() }
5993 pub union CResult_UpdateFailHTLCDecodeErrorZPtr {
5994 pub result: *mut crate::ln::msgs::UpdateFailHTLC,
5995 pub err: *mut crate::ln::msgs::DecodeError,
5998 pub struct CResult_UpdateFailHTLCDecodeErrorZ {
5999 pub contents: CResult_UpdateFailHTLCDecodeErrorZPtr,
6000 pub result_ok: bool,
6003 pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_ok(o: crate::ln::msgs::UpdateFailHTLC) -> CResult_UpdateFailHTLCDecodeErrorZ {
6004 CResult_UpdateFailHTLCDecodeErrorZ {
6005 contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
6006 result: Box::into_raw(Box::new(o)),
6012 pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UpdateFailHTLCDecodeErrorZ {
6013 CResult_UpdateFailHTLCDecodeErrorZ {
6014 contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
6015 err: Box::into_raw(Box::new(e)),
6021 pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_free(_res: CResult_UpdateFailHTLCDecodeErrorZ) { }
6022 impl Drop for CResult_UpdateFailHTLCDecodeErrorZ {
6023 fn drop(&mut self) {
6025 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6026 let _ = unsafe { Box::from_raw(self.contents.result) };
6029 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6030 let _ = unsafe { Box::from_raw(self.contents.err) };
6035 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UpdateFailHTLC, crate::ln::msgs::DecodeError>> for CResult_UpdateFailHTLCDecodeErrorZ {
6036 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UpdateFailHTLC, crate::ln::msgs::DecodeError>) -> Self {
6037 let contents = if o.result_ok {
6038 let result = unsafe { o.contents.result };
6039 unsafe { o.contents.result = std::ptr::null_mut() };
6040 CResult_UpdateFailHTLCDecodeErrorZPtr { result }
6042 let err = unsafe { o.contents.err };
6043 unsafe { o.contents.err = std::ptr::null_mut(); }
6044 CResult_UpdateFailHTLCDecodeErrorZPtr { err }
6048 result_ok: o.result_ok,
6052 impl Clone for CResult_UpdateFailHTLCDecodeErrorZ {
6053 fn clone(&self) -> Self {
6055 Self { result_ok: true, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
6056 result: Box::into_raw(Box::new(<crate::ln::msgs::UpdateFailHTLC>::clone(unsafe { &*self.contents.result })))
6059 Self { result_ok: false, contents: CResult_UpdateFailHTLCDecodeErrorZPtr {
6060 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6066 pub extern "C" fn CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailHTLCDecodeErrorZ) -> CResult_UpdateFailHTLCDecodeErrorZ { orig.clone() }
6068 pub union CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
6069 pub result: *mut crate::ln::msgs::UpdateFailMalformedHTLC,
6070 pub err: *mut crate::ln::msgs::DecodeError,
6073 pub struct CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6074 pub contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr,
6075 pub result_ok: bool,
6078 pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: crate::ln::msgs::UpdateFailMalformedHTLC) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6079 CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6080 contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
6081 result: Box::into_raw(Box::new(o)),
6087 pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6088 CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6089 contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
6090 err: Box::into_raw(Box::new(e)),
6096 pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: CResult_UpdateFailMalformedHTLCDecodeErrorZ) { }
6097 impl Drop for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6098 fn drop(&mut self) {
6100 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6101 let _ = unsafe { Box::from_raw(self.contents.result) };
6104 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6105 let _ = unsafe { Box::from_raw(self.contents.err) };
6110 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UpdateFailMalformedHTLC, crate::ln::msgs::DecodeError>> for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6111 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UpdateFailMalformedHTLC, crate::ln::msgs::DecodeError>) -> Self {
6112 let contents = if o.result_ok {
6113 let result = unsafe { o.contents.result };
6114 unsafe { o.contents.result = std::ptr::null_mut() };
6115 CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { result }
6117 let err = unsafe { o.contents.err };
6118 unsafe { o.contents.err = std::ptr::null_mut(); }
6119 CResult_UpdateFailMalformedHTLCDecodeErrorZPtr { err }
6123 result_ok: o.result_ok,
6127 impl Clone for CResult_UpdateFailMalformedHTLCDecodeErrorZ {
6128 fn clone(&self) -> Self {
6130 Self { result_ok: true, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
6131 result: Box::into_raw(Box::new(<crate::ln::msgs::UpdateFailMalformedHTLC>::clone(unsafe { &*self.contents.result })))
6134 Self { result_ok: false, contents: CResult_UpdateFailMalformedHTLCDecodeErrorZPtr {
6135 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6141 pub extern "C" fn CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFailMalformedHTLCDecodeErrorZ) -> CResult_UpdateFailMalformedHTLCDecodeErrorZ { orig.clone() }
6143 pub union CResult_UpdateFeeDecodeErrorZPtr {
6144 pub result: *mut crate::ln::msgs::UpdateFee,
6145 pub err: *mut crate::ln::msgs::DecodeError,
6148 pub struct CResult_UpdateFeeDecodeErrorZ {
6149 pub contents: CResult_UpdateFeeDecodeErrorZPtr,
6150 pub result_ok: bool,
6153 pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_ok(o: crate::ln::msgs::UpdateFee) -> CResult_UpdateFeeDecodeErrorZ {
6154 CResult_UpdateFeeDecodeErrorZ {
6155 contents: CResult_UpdateFeeDecodeErrorZPtr {
6156 result: Box::into_raw(Box::new(o)),
6162 pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UpdateFeeDecodeErrorZ {
6163 CResult_UpdateFeeDecodeErrorZ {
6164 contents: CResult_UpdateFeeDecodeErrorZPtr {
6165 err: Box::into_raw(Box::new(e)),
6171 pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_free(_res: CResult_UpdateFeeDecodeErrorZ) { }
6172 impl Drop for CResult_UpdateFeeDecodeErrorZ {
6173 fn drop(&mut self) {
6175 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6176 let _ = unsafe { Box::from_raw(self.contents.result) };
6179 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6180 let _ = unsafe { Box::from_raw(self.contents.err) };
6185 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UpdateFee, crate::ln::msgs::DecodeError>> for CResult_UpdateFeeDecodeErrorZ {
6186 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UpdateFee, crate::ln::msgs::DecodeError>) -> Self {
6187 let contents = if o.result_ok {
6188 let result = unsafe { o.contents.result };
6189 unsafe { o.contents.result = std::ptr::null_mut() };
6190 CResult_UpdateFeeDecodeErrorZPtr { result }
6192 let err = unsafe { o.contents.err };
6193 unsafe { o.contents.err = std::ptr::null_mut(); }
6194 CResult_UpdateFeeDecodeErrorZPtr { err }
6198 result_ok: o.result_ok,
6202 impl Clone for CResult_UpdateFeeDecodeErrorZ {
6203 fn clone(&self) -> Self {
6205 Self { result_ok: true, contents: CResult_UpdateFeeDecodeErrorZPtr {
6206 result: Box::into_raw(Box::new(<crate::ln::msgs::UpdateFee>::clone(unsafe { &*self.contents.result })))
6209 Self { result_ok: false, contents: CResult_UpdateFeeDecodeErrorZPtr {
6210 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6216 pub extern "C" fn CResult_UpdateFeeDecodeErrorZ_clone(orig: &CResult_UpdateFeeDecodeErrorZ) -> CResult_UpdateFeeDecodeErrorZ { orig.clone() }
6218 pub union CResult_UpdateFulfillHTLCDecodeErrorZPtr {
6219 pub result: *mut crate::ln::msgs::UpdateFulfillHTLC,
6220 pub err: *mut crate::ln::msgs::DecodeError,
6223 pub struct CResult_UpdateFulfillHTLCDecodeErrorZ {
6224 pub contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr,
6225 pub result_ok: bool,
6228 pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: crate::ln::msgs::UpdateFulfillHTLC) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
6229 CResult_UpdateFulfillHTLCDecodeErrorZ {
6230 contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
6231 result: Box::into_raw(Box::new(o)),
6237 pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UpdateFulfillHTLCDecodeErrorZ {
6238 CResult_UpdateFulfillHTLCDecodeErrorZ {
6239 contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
6240 err: Box::into_raw(Box::new(e)),
6246 pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: CResult_UpdateFulfillHTLCDecodeErrorZ) { }
6247 impl Drop for CResult_UpdateFulfillHTLCDecodeErrorZ {
6248 fn drop(&mut self) {
6250 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6251 let _ = unsafe { Box::from_raw(self.contents.result) };
6254 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6255 let _ = unsafe { Box::from_raw(self.contents.err) };
6260 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UpdateFulfillHTLC, crate::ln::msgs::DecodeError>> for CResult_UpdateFulfillHTLCDecodeErrorZ {
6261 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UpdateFulfillHTLC, crate::ln::msgs::DecodeError>) -> Self {
6262 let contents = if o.result_ok {
6263 let result = unsafe { o.contents.result };
6264 unsafe { o.contents.result = std::ptr::null_mut() };
6265 CResult_UpdateFulfillHTLCDecodeErrorZPtr { result }
6267 let err = unsafe { o.contents.err };
6268 unsafe { o.contents.err = std::ptr::null_mut(); }
6269 CResult_UpdateFulfillHTLCDecodeErrorZPtr { err }
6273 result_ok: o.result_ok,
6277 impl Clone for CResult_UpdateFulfillHTLCDecodeErrorZ {
6278 fn clone(&self) -> Self {
6280 Self { result_ok: true, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
6281 result: Box::into_raw(Box::new(<crate::ln::msgs::UpdateFulfillHTLC>::clone(unsafe { &*self.contents.result })))
6284 Self { result_ok: false, contents: CResult_UpdateFulfillHTLCDecodeErrorZPtr {
6285 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6291 pub extern "C" fn CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: &CResult_UpdateFulfillHTLCDecodeErrorZ) -> CResult_UpdateFulfillHTLCDecodeErrorZ { orig.clone() }
6293 pub union CResult_UpdateAddHTLCDecodeErrorZPtr {
6294 pub result: *mut crate::ln::msgs::UpdateAddHTLC,
6295 pub err: *mut crate::ln::msgs::DecodeError,
6298 pub struct CResult_UpdateAddHTLCDecodeErrorZ {
6299 pub contents: CResult_UpdateAddHTLCDecodeErrorZPtr,
6300 pub result_ok: bool,
6303 pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_ok(o: crate::ln::msgs::UpdateAddHTLC) -> CResult_UpdateAddHTLCDecodeErrorZ {
6304 CResult_UpdateAddHTLCDecodeErrorZ {
6305 contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
6306 result: Box::into_raw(Box::new(o)),
6312 pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UpdateAddHTLCDecodeErrorZ {
6313 CResult_UpdateAddHTLCDecodeErrorZ {
6314 contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
6315 err: Box::into_raw(Box::new(e)),
6321 pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_free(_res: CResult_UpdateAddHTLCDecodeErrorZ) { }
6322 impl Drop for CResult_UpdateAddHTLCDecodeErrorZ {
6323 fn drop(&mut self) {
6325 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6326 let _ = unsafe { Box::from_raw(self.contents.result) };
6329 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6330 let _ = unsafe { Box::from_raw(self.contents.err) };
6335 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UpdateAddHTLC, crate::ln::msgs::DecodeError>> for CResult_UpdateAddHTLCDecodeErrorZ {
6336 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UpdateAddHTLC, crate::ln::msgs::DecodeError>) -> Self {
6337 let contents = if o.result_ok {
6338 let result = unsafe { o.contents.result };
6339 unsafe { o.contents.result = std::ptr::null_mut() };
6340 CResult_UpdateAddHTLCDecodeErrorZPtr { result }
6342 let err = unsafe { o.contents.err };
6343 unsafe { o.contents.err = std::ptr::null_mut(); }
6344 CResult_UpdateAddHTLCDecodeErrorZPtr { err }
6348 result_ok: o.result_ok,
6352 impl Clone for CResult_UpdateAddHTLCDecodeErrorZ {
6353 fn clone(&self) -> Self {
6355 Self { result_ok: true, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
6356 result: Box::into_raw(Box::new(<crate::ln::msgs::UpdateAddHTLC>::clone(unsafe { &*self.contents.result })))
6359 Self { result_ok: false, contents: CResult_UpdateAddHTLCDecodeErrorZPtr {
6360 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6366 pub extern "C" fn CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: &CResult_UpdateAddHTLCDecodeErrorZ) -> CResult_UpdateAddHTLCDecodeErrorZ { orig.clone() }
6368 pub union CResult_PingDecodeErrorZPtr {
6369 pub result: *mut crate::ln::msgs::Ping,
6370 pub err: *mut crate::ln::msgs::DecodeError,
6373 pub struct CResult_PingDecodeErrorZ {
6374 pub contents: CResult_PingDecodeErrorZPtr,
6375 pub result_ok: bool,
6378 pub extern "C" fn CResult_PingDecodeErrorZ_ok(o: crate::ln::msgs::Ping) -> CResult_PingDecodeErrorZ {
6379 CResult_PingDecodeErrorZ {
6380 contents: CResult_PingDecodeErrorZPtr {
6381 result: Box::into_raw(Box::new(o)),
6387 pub extern "C" fn CResult_PingDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_PingDecodeErrorZ {
6388 CResult_PingDecodeErrorZ {
6389 contents: CResult_PingDecodeErrorZPtr {
6390 err: Box::into_raw(Box::new(e)),
6396 pub extern "C" fn CResult_PingDecodeErrorZ_free(_res: CResult_PingDecodeErrorZ) { }
6397 impl Drop for CResult_PingDecodeErrorZ {
6398 fn drop(&mut self) {
6400 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6401 let _ = unsafe { Box::from_raw(self.contents.result) };
6404 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6405 let _ = unsafe { Box::from_raw(self.contents.err) };
6410 impl From<crate::c_types::CResultTempl<crate::ln::msgs::Ping, crate::ln::msgs::DecodeError>> for CResult_PingDecodeErrorZ {
6411 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::Ping, crate::ln::msgs::DecodeError>) -> Self {
6412 let contents = if o.result_ok {
6413 let result = unsafe { o.contents.result };
6414 unsafe { o.contents.result = std::ptr::null_mut() };
6415 CResult_PingDecodeErrorZPtr { result }
6417 let err = unsafe { o.contents.err };
6418 unsafe { o.contents.err = std::ptr::null_mut(); }
6419 CResult_PingDecodeErrorZPtr { err }
6423 result_ok: o.result_ok,
6427 impl Clone for CResult_PingDecodeErrorZ {
6428 fn clone(&self) -> Self {
6430 Self { result_ok: true, contents: CResult_PingDecodeErrorZPtr {
6431 result: Box::into_raw(Box::new(<crate::ln::msgs::Ping>::clone(unsafe { &*self.contents.result })))
6434 Self { result_ok: false, contents: CResult_PingDecodeErrorZPtr {
6435 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6441 pub extern "C" fn CResult_PingDecodeErrorZ_clone(orig: &CResult_PingDecodeErrorZ) -> CResult_PingDecodeErrorZ { orig.clone() }
6443 pub union CResult_PongDecodeErrorZPtr {
6444 pub result: *mut crate::ln::msgs::Pong,
6445 pub err: *mut crate::ln::msgs::DecodeError,
6448 pub struct CResult_PongDecodeErrorZ {
6449 pub contents: CResult_PongDecodeErrorZPtr,
6450 pub result_ok: bool,
6453 pub extern "C" fn CResult_PongDecodeErrorZ_ok(o: crate::ln::msgs::Pong) -> CResult_PongDecodeErrorZ {
6454 CResult_PongDecodeErrorZ {
6455 contents: CResult_PongDecodeErrorZPtr {
6456 result: Box::into_raw(Box::new(o)),
6462 pub extern "C" fn CResult_PongDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_PongDecodeErrorZ {
6463 CResult_PongDecodeErrorZ {
6464 contents: CResult_PongDecodeErrorZPtr {
6465 err: Box::into_raw(Box::new(e)),
6471 pub extern "C" fn CResult_PongDecodeErrorZ_free(_res: CResult_PongDecodeErrorZ) { }
6472 impl Drop for CResult_PongDecodeErrorZ {
6473 fn drop(&mut self) {
6475 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6476 let _ = unsafe { Box::from_raw(self.contents.result) };
6479 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6480 let _ = unsafe { Box::from_raw(self.contents.err) };
6485 impl From<crate::c_types::CResultTempl<crate::ln::msgs::Pong, crate::ln::msgs::DecodeError>> for CResult_PongDecodeErrorZ {
6486 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::Pong, crate::ln::msgs::DecodeError>) -> Self {
6487 let contents = if o.result_ok {
6488 let result = unsafe { o.contents.result };
6489 unsafe { o.contents.result = std::ptr::null_mut() };
6490 CResult_PongDecodeErrorZPtr { result }
6492 let err = unsafe { o.contents.err };
6493 unsafe { o.contents.err = std::ptr::null_mut(); }
6494 CResult_PongDecodeErrorZPtr { err }
6498 result_ok: o.result_ok,
6502 impl Clone for CResult_PongDecodeErrorZ {
6503 fn clone(&self) -> Self {
6505 Self { result_ok: true, contents: CResult_PongDecodeErrorZPtr {
6506 result: Box::into_raw(Box::new(<crate::ln::msgs::Pong>::clone(unsafe { &*self.contents.result })))
6509 Self { result_ok: false, contents: CResult_PongDecodeErrorZPtr {
6510 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6516 pub extern "C" fn CResult_PongDecodeErrorZ_clone(orig: &CResult_PongDecodeErrorZ) -> CResult_PongDecodeErrorZ { orig.clone() }
6518 pub union CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
6519 pub result: *mut crate::ln::msgs::UnsignedChannelAnnouncement,
6520 pub err: *mut crate::ln::msgs::DecodeError,
6523 pub struct CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6524 pub contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr,
6525 pub result_ok: bool,
6528 pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: crate::ln::msgs::UnsignedChannelAnnouncement) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6529 CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6530 contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
6531 result: Box::into_raw(Box::new(o)),
6537 pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6538 CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6539 contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
6540 err: Box::into_raw(Box::new(e)),
6546 pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedChannelAnnouncementDecodeErrorZ) { }
6547 impl Drop for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6548 fn drop(&mut self) {
6550 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6551 let _ = unsafe { Box::from_raw(self.contents.result) };
6554 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6555 let _ = unsafe { Box::from_raw(self.contents.err) };
6560 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UnsignedChannelAnnouncement, crate::ln::msgs::DecodeError>> for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6561 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UnsignedChannelAnnouncement, crate::ln::msgs::DecodeError>) -> Self {
6562 let contents = if o.result_ok {
6563 let result = unsafe { o.contents.result };
6564 unsafe { o.contents.result = std::ptr::null_mut() };
6565 CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { result }
6567 let err = unsafe { o.contents.err };
6568 unsafe { o.contents.err = std::ptr::null_mut(); }
6569 CResult_UnsignedChannelAnnouncementDecodeErrorZPtr { err }
6573 result_ok: o.result_ok,
6577 impl Clone for CResult_UnsignedChannelAnnouncementDecodeErrorZ {
6578 fn clone(&self) -> Self {
6580 Self { result_ok: true, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
6581 result: Box::into_raw(Box::new(<crate::ln::msgs::UnsignedChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
6584 Self { result_ok: false, contents: CResult_UnsignedChannelAnnouncementDecodeErrorZPtr {
6585 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6591 pub extern "C" fn CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedChannelAnnouncementDecodeErrorZ) -> CResult_UnsignedChannelAnnouncementDecodeErrorZ { orig.clone() }
6593 pub union CResult_ChannelAnnouncementDecodeErrorZPtr {
6594 pub result: *mut crate::ln::msgs::ChannelAnnouncement,
6595 pub err: *mut crate::ln::msgs::DecodeError,
6598 pub struct CResult_ChannelAnnouncementDecodeErrorZ {
6599 pub contents: CResult_ChannelAnnouncementDecodeErrorZPtr,
6600 pub result_ok: bool,
6603 pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_ok(o: crate::ln::msgs::ChannelAnnouncement) -> CResult_ChannelAnnouncementDecodeErrorZ {
6604 CResult_ChannelAnnouncementDecodeErrorZ {
6605 contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
6606 result: Box::into_raw(Box::new(o)),
6612 pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelAnnouncementDecodeErrorZ {
6613 CResult_ChannelAnnouncementDecodeErrorZ {
6614 contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
6615 err: Box::into_raw(Box::new(e)),
6621 pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_free(_res: CResult_ChannelAnnouncementDecodeErrorZ) { }
6622 impl Drop for CResult_ChannelAnnouncementDecodeErrorZ {
6623 fn drop(&mut self) {
6625 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6626 let _ = unsafe { Box::from_raw(self.contents.result) };
6629 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6630 let _ = unsafe { Box::from_raw(self.contents.err) };
6635 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ChannelAnnouncement, crate::ln::msgs::DecodeError>> for CResult_ChannelAnnouncementDecodeErrorZ {
6636 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ChannelAnnouncement, crate::ln::msgs::DecodeError>) -> Self {
6637 let contents = if o.result_ok {
6638 let result = unsafe { o.contents.result };
6639 unsafe { o.contents.result = std::ptr::null_mut() };
6640 CResult_ChannelAnnouncementDecodeErrorZPtr { result }
6642 let err = unsafe { o.contents.err };
6643 unsafe { o.contents.err = std::ptr::null_mut(); }
6644 CResult_ChannelAnnouncementDecodeErrorZPtr { err }
6648 result_ok: o.result_ok,
6652 impl Clone for CResult_ChannelAnnouncementDecodeErrorZ {
6653 fn clone(&self) -> Self {
6655 Self { result_ok: true, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
6656 result: Box::into_raw(Box::new(<crate::ln::msgs::ChannelAnnouncement>::clone(unsafe { &*self.contents.result })))
6659 Self { result_ok: false, contents: CResult_ChannelAnnouncementDecodeErrorZPtr {
6660 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6666 pub extern "C" fn CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: &CResult_ChannelAnnouncementDecodeErrorZ) -> CResult_ChannelAnnouncementDecodeErrorZ { orig.clone() }
6668 pub union CResult_UnsignedChannelUpdateDecodeErrorZPtr {
6669 pub result: *mut crate::ln::msgs::UnsignedChannelUpdate,
6670 pub err: *mut crate::ln::msgs::DecodeError,
6673 pub struct CResult_UnsignedChannelUpdateDecodeErrorZ {
6674 pub contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr,
6675 pub result_ok: bool,
6678 pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: crate::ln::msgs::UnsignedChannelUpdate) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
6679 CResult_UnsignedChannelUpdateDecodeErrorZ {
6680 contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
6681 result: Box::into_raw(Box::new(o)),
6687 pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UnsignedChannelUpdateDecodeErrorZ {
6688 CResult_UnsignedChannelUpdateDecodeErrorZ {
6689 contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
6690 err: Box::into_raw(Box::new(e)),
6696 pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: CResult_UnsignedChannelUpdateDecodeErrorZ) { }
6697 impl Drop for CResult_UnsignedChannelUpdateDecodeErrorZ {
6698 fn drop(&mut self) {
6700 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6701 let _ = unsafe { Box::from_raw(self.contents.result) };
6704 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6705 let _ = unsafe { Box::from_raw(self.contents.err) };
6710 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UnsignedChannelUpdate, crate::ln::msgs::DecodeError>> for CResult_UnsignedChannelUpdateDecodeErrorZ {
6711 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UnsignedChannelUpdate, crate::ln::msgs::DecodeError>) -> Self {
6712 let contents = if o.result_ok {
6713 let result = unsafe { o.contents.result };
6714 unsafe { o.contents.result = std::ptr::null_mut() };
6715 CResult_UnsignedChannelUpdateDecodeErrorZPtr { result }
6717 let err = unsafe { o.contents.err };
6718 unsafe { o.contents.err = std::ptr::null_mut(); }
6719 CResult_UnsignedChannelUpdateDecodeErrorZPtr { err }
6723 result_ok: o.result_ok,
6727 impl Clone for CResult_UnsignedChannelUpdateDecodeErrorZ {
6728 fn clone(&self) -> Self {
6730 Self { result_ok: true, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
6731 result: Box::into_raw(Box::new(<crate::ln::msgs::UnsignedChannelUpdate>::clone(unsafe { &*self.contents.result })))
6734 Self { result_ok: false, contents: CResult_UnsignedChannelUpdateDecodeErrorZPtr {
6735 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6741 pub extern "C" fn CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: &CResult_UnsignedChannelUpdateDecodeErrorZ) -> CResult_UnsignedChannelUpdateDecodeErrorZ { orig.clone() }
6743 pub union CResult_ChannelUpdateDecodeErrorZPtr {
6744 pub result: *mut crate::ln::msgs::ChannelUpdate,
6745 pub err: *mut crate::ln::msgs::DecodeError,
6748 pub struct CResult_ChannelUpdateDecodeErrorZ {
6749 pub contents: CResult_ChannelUpdateDecodeErrorZPtr,
6750 pub result_ok: bool,
6753 pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_ok(o: crate::ln::msgs::ChannelUpdate) -> CResult_ChannelUpdateDecodeErrorZ {
6754 CResult_ChannelUpdateDecodeErrorZ {
6755 contents: CResult_ChannelUpdateDecodeErrorZPtr {
6756 result: Box::into_raw(Box::new(o)),
6762 pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ChannelUpdateDecodeErrorZ {
6763 CResult_ChannelUpdateDecodeErrorZ {
6764 contents: CResult_ChannelUpdateDecodeErrorZPtr {
6765 err: Box::into_raw(Box::new(e)),
6771 pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_free(_res: CResult_ChannelUpdateDecodeErrorZ) { }
6772 impl Drop for CResult_ChannelUpdateDecodeErrorZ {
6773 fn drop(&mut self) {
6775 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6776 let _ = unsafe { Box::from_raw(self.contents.result) };
6779 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6780 let _ = unsafe { Box::from_raw(self.contents.err) };
6785 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ChannelUpdate, crate::ln::msgs::DecodeError>> for CResult_ChannelUpdateDecodeErrorZ {
6786 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ChannelUpdate, crate::ln::msgs::DecodeError>) -> Self {
6787 let contents = if o.result_ok {
6788 let result = unsafe { o.contents.result };
6789 unsafe { o.contents.result = std::ptr::null_mut() };
6790 CResult_ChannelUpdateDecodeErrorZPtr { result }
6792 let err = unsafe { o.contents.err };
6793 unsafe { o.contents.err = std::ptr::null_mut(); }
6794 CResult_ChannelUpdateDecodeErrorZPtr { err }
6798 result_ok: o.result_ok,
6802 impl Clone for CResult_ChannelUpdateDecodeErrorZ {
6803 fn clone(&self) -> Self {
6805 Self { result_ok: true, contents: CResult_ChannelUpdateDecodeErrorZPtr {
6806 result: Box::into_raw(Box::new(<crate::ln::msgs::ChannelUpdate>::clone(unsafe { &*self.contents.result })))
6809 Self { result_ok: false, contents: CResult_ChannelUpdateDecodeErrorZPtr {
6810 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6816 pub extern "C" fn CResult_ChannelUpdateDecodeErrorZ_clone(orig: &CResult_ChannelUpdateDecodeErrorZ) -> CResult_ChannelUpdateDecodeErrorZ { orig.clone() }
6818 pub union CResult_ErrorMessageDecodeErrorZPtr {
6819 pub result: *mut crate::ln::msgs::ErrorMessage,
6820 pub err: *mut crate::ln::msgs::DecodeError,
6823 pub struct CResult_ErrorMessageDecodeErrorZ {
6824 pub contents: CResult_ErrorMessageDecodeErrorZPtr,
6825 pub result_ok: bool,
6828 pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_ok(o: crate::ln::msgs::ErrorMessage) -> CResult_ErrorMessageDecodeErrorZ {
6829 CResult_ErrorMessageDecodeErrorZ {
6830 contents: CResult_ErrorMessageDecodeErrorZPtr {
6831 result: Box::into_raw(Box::new(o)),
6837 pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ErrorMessageDecodeErrorZ {
6838 CResult_ErrorMessageDecodeErrorZ {
6839 contents: CResult_ErrorMessageDecodeErrorZPtr {
6840 err: Box::into_raw(Box::new(e)),
6846 pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_free(_res: CResult_ErrorMessageDecodeErrorZ) { }
6847 impl Drop for CResult_ErrorMessageDecodeErrorZ {
6848 fn drop(&mut self) {
6850 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6851 let _ = unsafe { Box::from_raw(self.contents.result) };
6854 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6855 let _ = unsafe { Box::from_raw(self.contents.err) };
6860 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ErrorMessage, crate::ln::msgs::DecodeError>> for CResult_ErrorMessageDecodeErrorZ {
6861 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ErrorMessage, crate::ln::msgs::DecodeError>) -> Self {
6862 let contents = if o.result_ok {
6863 let result = unsafe { o.contents.result };
6864 unsafe { o.contents.result = std::ptr::null_mut() };
6865 CResult_ErrorMessageDecodeErrorZPtr { result }
6867 let err = unsafe { o.contents.err };
6868 unsafe { o.contents.err = std::ptr::null_mut(); }
6869 CResult_ErrorMessageDecodeErrorZPtr { err }
6873 result_ok: o.result_ok,
6877 impl Clone for CResult_ErrorMessageDecodeErrorZ {
6878 fn clone(&self) -> Self {
6880 Self { result_ok: true, contents: CResult_ErrorMessageDecodeErrorZPtr {
6881 result: Box::into_raw(Box::new(<crate::ln::msgs::ErrorMessage>::clone(unsafe { &*self.contents.result })))
6884 Self { result_ok: false, contents: CResult_ErrorMessageDecodeErrorZPtr {
6885 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6891 pub extern "C" fn CResult_ErrorMessageDecodeErrorZ_clone(orig: &CResult_ErrorMessageDecodeErrorZ) -> CResult_ErrorMessageDecodeErrorZ { orig.clone() }
6893 pub union CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
6894 pub result: *mut crate::ln::msgs::UnsignedNodeAnnouncement,
6895 pub err: *mut crate::ln::msgs::DecodeError,
6898 pub struct CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6899 pub contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr,
6900 pub result_ok: bool,
6903 pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: crate::ln::msgs::UnsignedNodeAnnouncement) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6904 CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6905 contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
6906 result: Box::into_raw(Box::new(o)),
6912 pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6913 CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6914 contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
6915 err: Box::into_raw(Box::new(e)),
6921 pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: CResult_UnsignedNodeAnnouncementDecodeErrorZ) { }
6922 impl Drop for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6923 fn drop(&mut self) {
6925 if unsafe { !(self.contents.result as *mut ()).is_null() } {
6926 let _ = unsafe { Box::from_raw(self.contents.result) };
6929 if unsafe { !(self.contents.err as *mut ()).is_null() } {
6930 let _ = unsafe { Box::from_raw(self.contents.err) };
6935 impl From<crate::c_types::CResultTempl<crate::ln::msgs::UnsignedNodeAnnouncement, crate::ln::msgs::DecodeError>> for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6936 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::UnsignedNodeAnnouncement, crate::ln::msgs::DecodeError>) -> Self {
6937 let contents = if o.result_ok {
6938 let result = unsafe { o.contents.result };
6939 unsafe { o.contents.result = std::ptr::null_mut() };
6940 CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { result }
6942 let err = unsafe { o.contents.err };
6943 unsafe { o.contents.err = std::ptr::null_mut(); }
6944 CResult_UnsignedNodeAnnouncementDecodeErrorZPtr { err }
6948 result_ok: o.result_ok,
6952 impl Clone for CResult_UnsignedNodeAnnouncementDecodeErrorZ {
6953 fn clone(&self) -> Self {
6955 Self { result_ok: true, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
6956 result: Box::into_raw(Box::new(<crate::ln::msgs::UnsignedNodeAnnouncement>::clone(unsafe { &*self.contents.result })))
6959 Self { result_ok: false, contents: CResult_UnsignedNodeAnnouncementDecodeErrorZPtr {
6960 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
6966 pub extern "C" fn CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: &CResult_UnsignedNodeAnnouncementDecodeErrorZ) -> CResult_UnsignedNodeAnnouncementDecodeErrorZ { orig.clone() }
6968 pub union CResult_NodeAnnouncementDecodeErrorZPtr {
6969 pub result: *mut crate::ln::msgs::NodeAnnouncement,
6970 pub err: *mut crate::ln::msgs::DecodeError,
6973 pub struct CResult_NodeAnnouncementDecodeErrorZ {
6974 pub contents: CResult_NodeAnnouncementDecodeErrorZPtr,
6975 pub result_ok: bool,
6978 pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_ok(o: crate::ln::msgs::NodeAnnouncement) -> CResult_NodeAnnouncementDecodeErrorZ {
6979 CResult_NodeAnnouncementDecodeErrorZ {
6980 contents: CResult_NodeAnnouncementDecodeErrorZPtr {
6981 result: Box::into_raw(Box::new(o)),
6987 pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_NodeAnnouncementDecodeErrorZ {
6988 CResult_NodeAnnouncementDecodeErrorZ {
6989 contents: CResult_NodeAnnouncementDecodeErrorZPtr {
6990 err: Box::into_raw(Box::new(e)),
6996 pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_free(_res: CResult_NodeAnnouncementDecodeErrorZ) { }
6997 impl Drop for CResult_NodeAnnouncementDecodeErrorZ {
6998 fn drop(&mut self) {
7000 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7001 let _ = unsafe { Box::from_raw(self.contents.result) };
7004 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7005 let _ = unsafe { Box::from_raw(self.contents.err) };
7010 impl From<crate::c_types::CResultTempl<crate::ln::msgs::NodeAnnouncement, crate::ln::msgs::DecodeError>> for CResult_NodeAnnouncementDecodeErrorZ {
7011 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::NodeAnnouncement, crate::ln::msgs::DecodeError>) -> Self {
7012 let contents = if o.result_ok {
7013 let result = unsafe { o.contents.result };
7014 unsafe { o.contents.result = std::ptr::null_mut() };
7015 CResult_NodeAnnouncementDecodeErrorZPtr { result }
7017 let err = unsafe { o.contents.err };
7018 unsafe { o.contents.err = std::ptr::null_mut(); }
7019 CResult_NodeAnnouncementDecodeErrorZPtr { err }
7023 result_ok: o.result_ok,
7027 impl Clone for CResult_NodeAnnouncementDecodeErrorZ {
7028 fn clone(&self) -> Self {
7030 Self { result_ok: true, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
7031 result: Box::into_raw(Box::new(<crate::ln::msgs::NodeAnnouncement>::clone(unsafe { &*self.contents.result })))
7034 Self { result_ok: false, contents: CResult_NodeAnnouncementDecodeErrorZPtr {
7035 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7041 pub extern "C" fn CResult_NodeAnnouncementDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementDecodeErrorZ) -> CResult_NodeAnnouncementDecodeErrorZ { orig.clone() }
7043 pub union CResult_QueryShortChannelIdsDecodeErrorZPtr {
7044 pub result: *mut crate::ln::msgs::QueryShortChannelIds,
7045 pub err: *mut crate::ln::msgs::DecodeError,
7048 pub struct CResult_QueryShortChannelIdsDecodeErrorZ {
7049 pub contents: CResult_QueryShortChannelIdsDecodeErrorZPtr,
7050 pub result_ok: bool,
7053 pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: crate::ln::msgs::QueryShortChannelIds) -> CResult_QueryShortChannelIdsDecodeErrorZ {
7054 CResult_QueryShortChannelIdsDecodeErrorZ {
7055 contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
7056 result: Box::into_raw(Box::new(o)),
7062 pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_QueryShortChannelIdsDecodeErrorZ {
7063 CResult_QueryShortChannelIdsDecodeErrorZ {
7064 contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
7065 err: Box::into_raw(Box::new(e)),
7071 pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: CResult_QueryShortChannelIdsDecodeErrorZ) { }
7072 impl Drop for CResult_QueryShortChannelIdsDecodeErrorZ {
7073 fn drop(&mut self) {
7075 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7076 let _ = unsafe { Box::from_raw(self.contents.result) };
7079 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7080 let _ = unsafe { Box::from_raw(self.contents.err) };
7085 impl From<crate::c_types::CResultTempl<crate::ln::msgs::QueryShortChannelIds, crate::ln::msgs::DecodeError>> for CResult_QueryShortChannelIdsDecodeErrorZ {
7086 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::QueryShortChannelIds, crate::ln::msgs::DecodeError>) -> Self {
7087 let contents = if o.result_ok {
7088 let result = unsafe { o.contents.result };
7089 unsafe { o.contents.result = std::ptr::null_mut() };
7090 CResult_QueryShortChannelIdsDecodeErrorZPtr { result }
7092 let err = unsafe { o.contents.err };
7093 unsafe { o.contents.err = std::ptr::null_mut(); }
7094 CResult_QueryShortChannelIdsDecodeErrorZPtr { err }
7098 result_ok: o.result_ok,
7102 impl Clone for CResult_QueryShortChannelIdsDecodeErrorZ {
7103 fn clone(&self) -> Self {
7105 Self { result_ok: true, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
7106 result: Box::into_raw(Box::new(<crate::ln::msgs::QueryShortChannelIds>::clone(unsafe { &*self.contents.result })))
7109 Self { result_ok: false, contents: CResult_QueryShortChannelIdsDecodeErrorZPtr {
7110 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7116 pub extern "C" fn CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: &CResult_QueryShortChannelIdsDecodeErrorZ) -> CResult_QueryShortChannelIdsDecodeErrorZ { orig.clone() }
7118 pub union CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
7119 pub result: *mut crate::ln::msgs::ReplyShortChannelIdsEnd,
7120 pub err: *mut crate::ln::msgs::DecodeError,
7123 pub struct CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7124 pub contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr,
7125 pub result_ok: bool,
7128 pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: crate::ln::msgs::ReplyShortChannelIdsEnd) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7129 CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7130 contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
7131 result: Box::into_raw(Box::new(o)),
7137 pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7138 CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7139 contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
7140 err: Box::into_raw(Box::new(e)),
7146 pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: CResult_ReplyShortChannelIdsEndDecodeErrorZ) { }
7147 impl Drop for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7148 fn drop(&mut self) {
7150 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7151 let _ = unsafe { Box::from_raw(self.contents.result) };
7154 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7155 let _ = unsafe { Box::from_raw(self.contents.err) };
7160 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ReplyShortChannelIdsEnd, crate::ln::msgs::DecodeError>> for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7161 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ReplyShortChannelIdsEnd, crate::ln::msgs::DecodeError>) -> Self {
7162 let contents = if o.result_ok {
7163 let result = unsafe { o.contents.result };
7164 unsafe { o.contents.result = std::ptr::null_mut() };
7165 CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { result }
7167 let err = unsafe { o.contents.err };
7168 unsafe { o.contents.err = std::ptr::null_mut(); }
7169 CResult_ReplyShortChannelIdsEndDecodeErrorZPtr { err }
7173 result_ok: o.result_ok,
7177 impl Clone for CResult_ReplyShortChannelIdsEndDecodeErrorZ {
7178 fn clone(&self) -> Self {
7180 Self { result_ok: true, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
7181 result: Box::into_raw(Box::new(<crate::ln::msgs::ReplyShortChannelIdsEnd>::clone(unsafe { &*self.contents.result })))
7184 Self { result_ok: false, contents: CResult_ReplyShortChannelIdsEndDecodeErrorZPtr {
7185 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7191 pub extern "C" fn CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: &CResult_ReplyShortChannelIdsEndDecodeErrorZ) -> CResult_ReplyShortChannelIdsEndDecodeErrorZ { orig.clone() }
7193 pub union CResult_QueryChannelRangeDecodeErrorZPtr {
7194 pub result: *mut crate::ln::msgs::QueryChannelRange,
7195 pub err: *mut crate::ln::msgs::DecodeError,
7198 pub struct CResult_QueryChannelRangeDecodeErrorZ {
7199 pub contents: CResult_QueryChannelRangeDecodeErrorZPtr,
7200 pub result_ok: bool,
7203 pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_ok(o: crate::ln::msgs::QueryChannelRange) -> CResult_QueryChannelRangeDecodeErrorZ {
7204 CResult_QueryChannelRangeDecodeErrorZ {
7205 contents: CResult_QueryChannelRangeDecodeErrorZPtr {
7206 result: Box::into_raw(Box::new(o)),
7212 pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_QueryChannelRangeDecodeErrorZ {
7213 CResult_QueryChannelRangeDecodeErrorZ {
7214 contents: CResult_QueryChannelRangeDecodeErrorZPtr {
7215 err: Box::into_raw(Box::new(e)),
7221 pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_free(_res: CResult_QueryChannelRangeDecodeErrorZ) { }
7222 impl Drop for CResult_QueryChannelRangeDecodeErrorZ {
7223 fn drop(&mut self) {
7225 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7226 let _ = unsafe { Box::from_raw(self.contents.result) };
7229 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7230 let _ = unsafe { Box::from_raw(self.contents.err) };
7235 impl From<crate::c_types::CResultTempl<crate::ln::msgs::QueryChannelRange, crate::ln::msgs::DecodeError>> for CResult_QueryChannelRangeDecodeErrorZ {
7236 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::QueryChannelRange, crate::ln::msgs::DecodeError>) -> Self {
7237 let contents = if o.result_ok {
7238 let result = unsafe { o.contents.result };
7239 unsafe { o.contents.result = std::ptr::null_mut() };
7240 CResult_QueryChannelRangeDecodeErrorZPtr { result }
7242 let err = unsafe { o.contents.err };
7243 unsafe { o.contents.err = std::ptr::null_mut(); }
7244 CResult_QueryChannelRangeDecodeErrorZPtr { err }
7248 result_ok: o.result_ok,
7252 impl Clone for CResult_QueryChannelRangeDecodeErrorZ {
7253 fn clone(&self) -> Self {
7255 Self { result_ok: true, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
7256 result: Box::into_raw(Box::new(<crate::ln::msgs::QueryChannelRange>::clone(unsafe { &*self.contents.result })))
7259 Self { result_ok: false, contents: CResult_QueryChannelRangeDecodeErrorZPtr {
7260 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7266 pub extern "C" fn CResult_QueryChannelRangeDecodeErrorZ_clone(orig: &CResult_QueryChannelRangeDecodeErrorZ) -> CResult_QueryChannelRangeDecodeErrorZ { orig.clone() }
7268 pub union CResult_ReplyChannelRangeDecodeErrorZPtr {
7269 pub result: *mut crate::ln::msgs::ReplyChannelRange,
7270 pub err: *mut crate::ln::msgs::DecodeError,
7273 pub struct CResult_ReplyChannelRangeDecodeErrorZ {
7274 pub contents: CResult_ReplyChannelRangeDecodeErrorZPtr,
7275 pub result_ok: bool,
7278 pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_ok(o: crate::ln::msgs::ReplyChannelRange) -> CResult_ReplyChannelRangeDecodeErrorZ {
7279 CResult_ReplyChannelRangeDecodeErrorZ {
7280 contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
7281 result: Box::into_raw(Box::new(o)),
7287 pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_ReplyChannelRangeDecodeErrorZ {
7288 CResult_ReplyChannelRangeDecodeErrorZ {
7289 contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
7290 err: Box::into_raw(Box::new(e)),
7296 pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_free(_res: CResult_ReplyChannelRangeDecodeErrorZ) { }
7297 impl Drop for CResult_ReplyChannelRangeDecodeErrorZ {
7298 fn drop(&mut self) {
7300 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7301 let _ = unsafe { Box::from_raw(self.contents.result) };
7304 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7305 let _ = unsafe { Box::from_raw(self.contents.err) };
7310 impl From<crate::c_types::CResultTempl<crate::ln::msgs::ReplyChannelRange, crate::ln::msgs::DecodeError>> for CResult_ReplyChannelRangeDecodeErrorZ {
7311 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::ReplyChannelRange, crate::ln::msgs::DecodeError>) -> Self {
7312 let contents = if o.result_ok {
7313 let result = unsafe { o.contents.result };
7314 unsafe { o.contents.result = std::ptr::null_mut() };
7315 CResult_ReplyChannelRangeDecodeErrorZPtr { result }
7317 let err = unsafe { o.contents.err };
7318 unsafe { o.contents.err = std::ptr::null_mut(); }
7319 CResult_ReplyChannelRangeDecodeErrorZPtr { err }
7323 result_ok: o.result_ok,
7327 impl Clone for CResult_ReplyChannelRangeDecodeErrorZ {
7328 fn clone(&self) -> Self {
7330 Self { result_ok: true, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
7331 result: Box::into_raw(Box::new(<crate::ln::msgs::ReplyChannelRange>::clone(unsafe { &*self.contents.result })))
7334 Self { result_ok: false, contents: CResult_ReplyChannelRangeDecodeErrorZPtr {
7335 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7341 pub extern "C" fn CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: &CResult_ReplyChannelRangeDecodeErrorZ) -> CResult_ReplyChannelRangeDecodeErrorZ { orig.clone() }
7343 pub union CResult_GossipTimestampFilterDecodeErrorZPtr {
7344 pub result: *mut crate::ln::msgs::GossipTimestampFilter,
7345 pub err: *mut crate::ln::msgs::DecodeError,
7348 pub struct CResult_GossipTimestampFilterDecodeErrorZ {
7349 pub contents: CResult_GossipTimestampFilterDecodeErrorZPtr,
7350 pub result_ok: bool,
7353 pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_ok(o: crate::ln::msgs::GossipTimestampFilter) -> CResult_GossipTimestampFilterDecodeErrorZ {
7354 CResult_GossipTimestampFilterDecodeErrorZ {
7355 contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
7356 result: Box::into_raw(Box::new(o)),
7362 pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_err(e: crate::ln::msgs::DecodeError) -> CResult_GossipTimestampFilterDecodeErrorZ {
7363 CResult_GossipTimestampFilterDecodeErrorZ {
7364 contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
7365 err: Box::into_raw(Box::new(e)),
7371 pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_free(_res: CResult_GossipTimestampFilterDecodeErrorZ) { }
7372 impl Drop for CResult_GossipTimestampFilterDecodeErrorZ {
7373 fn drop(&mut self) {
7375 if unsafe { !(self.contents.result as *mut ()).is_null() } {
7376 let _ = unsafe { Box::from_raw(self.contents.result) };
7379 if unsafe { !(self.contents.err as *mut ()).is_null() } {
7380 let _ = unsafe { Box::from_raw(self.contents.err) };
7385 impl From<crate::c_types::CResultTempl<crate::ln::msgs::GossipTimestampFilter, crate::ln::msgs::DecodeError>> for CResult_GossipTimestampFilterDecodeErrorZ {
7386 fn from(mut o: crate::c_types::CResultTempl<crate::ln::msgs::GossipTimestampFilter, crate::ln::msgs::DecodeError>) -> Self {
7387 let contents = if o.result_ok {
7388 let result = unsafe { o.contents.result };
7389 unsafe { o.contents.result = std::ptr::null_mut() };
7390 CResult_GossipTimestampFilterDecodeErrorZPtr { result }
7392 let err = unsafe { o.contents.err };
7393 unsafe { o.contents.err = std::ptr::null_mut(); }
7394 CResult_GossipTimestampFilterDecodeErrorZPtr { err }
7398 result_ok: o.result_ok,
7402 impl Clone for CResult_GossipTimestampFilterDecodeErrorZ {
7403 fn clone(&self) -> Self {
7405 Self { result_ok: true, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
7406 result: Box::into_raw(Box::new(<crate::ln::msgs::GossipTimestampFilter>::clone(unsafe { &*self.contents.result })))
7409 Self { result_ok: false, contents: CResult_GossipTimestampFilterDecodeErrorZPtr {
7410 err: Box::into_raw(Box::new(<crate::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
7416 pub extern "C" fn CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: &CResult_GossipTimestampFilterDecodeErrorZ) -> CResult_GossipTimestampFilterDecodeErrorZ { orig.clone() }