_ Git - ldk-java/blob - src/main/java/org/ldk/structs/OffersMessage.java

   1 package org.ldk.structs;
   2
   3 import org.ldk.impl.bindings;
   4 import org.ldk.enums.*;
   5 import org.ldk.util.*;
   6 import java.util.Arrays;
   7 import java.lang.ref.Reference;
   8 import javax.annotation.Nullable;
   9
  10
  11 /**
  12  * Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
  13  *
  14  * [`OnionMessage`]: crate::ln::msgs::OnionMessage
  15  */
  16 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  17 public class OffersMessage extends CommonBase {
  18         private OffersMessage(Object _dummy, long ptr) { super(ptr); }
  19         @Override @SuppressWarnings("deprecation")
  20         protected void finalize() throws Throwable {
  21                 super.finalize();
  22                 if (ptr != 0) { bindings.OffersMessage_free(ptr); }
  23         }
  24         static OffersMessage constr_from_ptr(long ptr) {
  25                 bindings.LDKOffersMessage raw_val = bindings.LDKOffersMessage_ref_from_ptr(ptr);
  26                 if (raw_val.getClass() == bindings.LDKOffersMessage.InvoiceRequest.class) {
  27                         return new InvoiceRequest(ptr, (bindings.LDKOffersMessage.InvoiceRequest)raw_val);
  28                 }
  29                 if (raw_val.getClass() == bindings.LDKOffersMessage.Invoice.class) {
  30                         return new Invoice(ptr, (bindings.LDKOffersMessage.Invoice)raw_val);
  31                 }
  32                 if (raw_val.getClass() == bindings.LDKOffersMessage.InvoiceError.class) {
  33                         return new InvoiceError(ptr, (bindings.LDKOffersMessage.InvoiceError)raw_val);
  34                 }
  35                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  36         }
  37
  38         /**
  39          * A request for a [`Bolt12Invoice`] for a particular [`Offer`].
  40          *
  41          * [`Offer`]: crate::offers::offer::Offer
  42          */
  43         public final static class InvoiceRequest extends OffersMessage {
  44                 public final org.ldk.structs.InvoiceRequest invoice_request;
  45                 private InvoiceRequest(long ptr, bindings.LDKOffersMessage.InvoiceRequest obj) {
  46                         super(null, ptr);
  47                         long invoice_request = obj.invoice_request;
  48                         org.ldk.structs.InvoiceRequest invoice_request_hu_conv = null; if (invoice_request < 0 || invoice_request > 4096) { invoice_request_hu_conv = new org.ldk.structs.InvoiceRequest(null, invoice_request); }
  49                         if (invoice_request_hu_conv != null) { invoice_request_hu_conv.ptrs_to.add(this); };
  50                         this.invoice_request = invoice_request_hu_conv;
  51                 }
  52         }
  53         /**
  54          * A [`Bolt12Invoice`] sent in response to an [`InvoiceRequest`] or a [`Refund`].
  55          *
  56          * [`Refund`]: crate::offers::refund::Refund
  57          */
  58         public final static class Invoice extends OffersMessage {
  59                 public final org.ldk.structs.Bolt12Invoice invoice;
  60                 private Invoice(long ptr, bindings.LDKOffersMessage.Invoice obj) {
  61                         super(null, ptr);
  62                         long invoice = obj.invoice;
  63                         org.ldk.structs.Bolt12Invoice invoice_hu_conv = null; if (invoice < 0 || invoice > 4096) { invoice_hu_conv = new org.ldk.structs.Bolt12Invoice(null, invoice); }
  64                         if (invoice_hu_conv != null) { invoice_hu_conv.ptrs_to.add(this); };
  65                         this.invoice = invoice_hu_conv;
  66                 }
  67         }
  68         /**
  69          * An error from handling an [`OffersMessage`].
  70          */
  71         public final static class InvoiceError extends OffersMessage {
  72                 public final org.ldk.structs.InvoiceError invoice_error;
  73                 private InvoiceError(long ptr, bindings.LDKOffersMessage.InvoiceError obj) {
  74                         super(null, ptr);
  75                         long invoice_error = obj.invoice_error;
  76                         org.ldk.structs.InvoiceError invoice_error_hu_conv = null; if (invoice_error < 0 || invoice_error > 4096) { invoice_error_hu_conv = new org.ldk.structs.InvoiceError(null, invoice_error); }
  77                         if (invoice_error_hu_conv != null) { invoice_error_hu_conv.ptrs_to.add(this); };
  78                         this.invoice_error = invoice_error_hu_conv;
  79                 }
  80         }
  81         long clone_ptr() {
  82                 long ret = bindings.OffersMessage_clone_ptr(this.ptr);
  83                 Reference.reachabilityFence(this);
  84                 return ret;
  85         }
  86
  87         /**
  88          * Creates a copy of the OffersMessage
  89          */
  90         public OffersMessage clone() {
  91                 long ret = bindings.OffersMessage_clone(this.ptr);
  92                 Reference.reachabilityFence(this);
  93                 if (ret >= 0 && ret <= 4096) { return null; }
  94                 org.ldk.structs.OffersMessage ret_hu_conv = org.ldk.structs.OffersMessage.constr_from_ptr(ret);
  95                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
  96                 return ret_hu_conv;
  97         }
  98
  99         /**
 100          * Utility method to constructs a new InvoiceRequest-variant OffersMessage
 101          */
 102         public static OffersMessage invoice_request(org.ldk.structs.InvoiceRequest a) {
 103                 long ret = bindings.OffersMessage_invoice_request(a == null ? 0 : a.ptr);
 104                 Reference.reachabilityFence(a);
 105                 if (ret >= 0 && ret <= 4096) { return null; }
 106                 org.ldk.structs.OffersMessage ret_hu_conv = org.ldk.structs.OffersMessage.constr_from_ptr(ret);
 107                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 108                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 109                 return ret_hu_conv;
 110         }
 111
 112         /**
 113          * Utility method to constructs a new Invoice-variant OffersMessage
 114          */
 115         public static OffersMessage invoice(org.ldk.structs.Bolt12Invoice a) {
 116                 long ret = bindings.OffersMessage_invoice(a == null ? 0 : a.ptr);
 117                 Reference.reachabilityFence(a);
 118                 if (ret >= 0 && ret <= 4096) { return null; }
 119                 org.ldk.structs.OffersMessage ret_hu_conv = org.ldk.structs.OffersMessage.constr_from_ptr(ret);
 120                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 121                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 122                 return ret_hu_conv;
 123         }
 124
 125         /**
 126          * Utility method to constructs a new InvoiceError-variant OffersMessage
 127          */
 128         public static OffersMessage invoice_error(org.ldk.structs.InvoiceError a) {
 129                 long ret = bindings.OffersMessage_invoice_error(a == null ? 0 : a.ptr);
 130                 Reference.reachabilityFence(a);
 131                 if (ret >= 0 && ret <= 4096) { return null; }
 132                 org.ldk.structs.OffersMessage ret_hu_conv = org.ldk.structs.OffersMessage.constr_from_ptr(ret);
 133                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 134                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 135                 return ret_hu_conv;
 136         }
 137
 138         /**
 139          * Constructs a new OnionMessageContents which calls the relevant methods on this_arg.
 140          * This copies the `inner` pointer in this_arg and thus the returned OnionMessageContents must be freed before this_arg is
 141          */
 142         public OnionMessageContents as_OnionMessageContents() {
 143                 long ret = bindings.OffersMessage_as_OnionMessageContents(this.ptr);
 144                 Reference.reachabilityFence(this);
 145                 if (ret >= 0 && ret <= 4096) { return null; }
 146                 OnionMessageContents ret_hu_conv = new OnionMessageContents(null, ret);
 147                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 148                 return ret_hu_conv;
 149         }
 150
 151         /**
 152          * Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read
 153          */
 154         public byte[] write() {
 155                 byte[] ret = bindings.OffersMessage_write(this.ptr);
 156                 Reference.reachabilityFence(this);
 157                 return ret;
 158         }
 159
 160         /**
 161          * Read a OffersMessage from a byte array, created by OffersMessage_write
 162          */
 163         public static Result_OffersMessageDecodeErrorZ read(byte[] ser, long arg_a, org.ldk.structs.Logger arg_b) {
 164                 long ret = bindings.OffersMessage_read(ser, arg_a, arg_b.ptr);
 165                 Reference.reachabilityFence(ser);
 166                 Reference.reachabilityFence(arg_a);
 167                 Reference.reachabilityFence(arg_b);
 168                 if (ret >= 0 && ret <= 4096) { return null; }
 169                 Result_OffersMessageDecodeErrorZ ret_hu_conv = Result_OffersMessageDecodeErrorZ.constr_from_ptr(ret);
 170                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(arg_b); };
 171                 return ret_hu_conv;
 172         }
 173
 174 }