git.bitcoin.ninja Git - ldk-java/blob - src/main/java/org/ldk/structs/Amount.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  * The minimum amount required for an item in an [`Offer`], denominated in either bitcoin or
  13  * another currency.
  14  */
  15 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  16 public class Amount extends CommonBase {
  17         private Amount(Object _dummy, long ptr) { super(ptr); }
  18         @Override @SuppressWarnings("deprecation")
  19         protected void finalize() throws Throwable {
  20                 super.finalize();
  21                 if (ptr != 0) { bindings.Amount_free(ptr); }
  22         }
  23         static Amount constr_from_ptr(long ptr) {
  24                 bindings.LDKAmount raw_val = bindings.LDKAmount_ref_from_ptr(ptr);
  25                 if (raw_val.getClass() == bindings.LDKAmount.Bitcoin.class) {
  26                         return new Bitcoin(ptr, (bindings.LDKAmount.Bitcoin)raw_val);
  27                 }
  28                 if (raw_val.getClass() == bindings.LDKAmount.Currency.class) {
  29                         return new Currency(ptr, (bindings.LDKAmount.Currency)raw_val);
  30                 }
  31                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  32         }
  33
  34         /**
  35          * An amount of bitcoin.
  36          */
  37         public final static class Bitcoin extends Amount {
  38                 /**
  39                  * The amount in millisatoshi.
  40                 */
  41                 public final long amount_msats;
  42                 private Bitcoin(long ptr, bindings.LDKAmount.Bitcoin obj) {
  43                         super(null, ptr);
  44                         this.amount_msats = obj.amount_msats;
  45                 }
  46         }
  47         /**
  48          * An amount of currency specified using ISO 4712.
  49          */
  50         public final static class Currency extends Amount {
  51                 /**
  52                  * The currency that the amount is denominated in.
  53                 */
  54                 public final byte[] iso4217_code;
  55                 /**
  56                  * The amount in the currency unit adjusted by the ISO 4712 exponent (e.g., USD cents).
  57                 */
  58                 public final long amount;
  59                 private Currency(long ptr, bindings.LDKAmount.Currency obj) {
  60                         super(null, ptr);
  61                         this.iso4217_code = obj.iso4217_code;
  62                         this.amount = obj.amount;
  63                 }
  64         }
  65         long clone_ptr() {
  66                 long ret = bindings.Amount_clone_ptr(this.ptr);
  67                 Reference.reachabilityFence(this);
  68                 return ret;
  69         }
  70
  71         /**
  72          * Creates a copy of the Amount
  73          */
  74         public Amount clone() {
  75                 long ret = bindings.Amount_clone(this.ptr);
  76                 Reference.reachabilityFence(this);
  77                 if (ret >= 0 && ret <= 4096) { return null; }
  78                 org.ldk.structs.Amount ret_hu_conv = org.ldk.structs.Amount.constr_from_ptr(ret);
  79                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
  80                 return ret_hu_conv;
  81         }
  82
  83         /**
  84          * Utility method to constructs a new Bitcoin-variant Amount
  85          */
  86         public static Amount bitcoin(long amount_msats) {
  87                 long ret = bindings.Amount_bitcoin(amount_msats);
  88                 Reference.reachabilityFence(amount_msats);
  89                 if (ret >= 0 && ret <= 4096) { return null; }
  90                 org.ldk.structs.Amount ret_hu_conv = org.ldk.structs.Amount.constr_from_ptr(ret);
  91                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  92                 return ret_hu_conv;
  93         }
  94
  95         /**
  96          * Utility method to constructs a new Currency-variant Amount
  97          */
  98         public static Amount currency(byte[] iso4217_code, long amount) {
  99                 long ret = bindings.Amount_currency(InternalUtils.check_arr_len(iso4217_code, 3), amount);
 100                 Reference.reachabilityFence(iso4217_code);
 101                 Reference.reachabilityFence(amount);
 102                 if (ret >= 0 && ret <= 4096) { return null; }
 103                 org.ldk.structs.Amount ret_hu_conv = org.ldk.structs.Amount.constr_from_ptr(ret);
 104                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 105                 return ret_hu_conv;
 106         }
 107
 108 }