_ Git - ldk-java/blob - src/main/java/org/ldk/structs/DirectionalChannelInfo.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 javax.annotation.Nullable;
   8
   9
  10 /**
  11  * Details about one direction of a channel. Received
  12  * within a channel update.
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class DirectionalChannelInfo extends CommonBase {
  16         DirectionalChannelInfo(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.DirectionalChannelInfo_free(ptr); }
  21         }
  22
  23         /**
  24          * When the last update to the channel direction was issued.
  25          * Value is opaque, as set in the announcement.
  26          */
  27         public int get_last_update() {
  28                 int ret = bindings.DirectionalChannelInfo_get_last_update(this.ptr);
  29                 return ret;
  30         }
  31
  32         /**
  33          * When the last update to the channel direction was issued.
  34          * Value is opaque, as set in the announcement.
  35          */
  36         public void set_last_update(int val) {
  37                 bindings.DirectionalChannelInfo_set_last_update(this.ptr, val);
  38         }
  39
  40         /**
  41          * Whether the channel can be currently used for payments (in this one direction).
  42          */
  43         public boolean get_enabled() {
  44                 boolean ret = bindings.DirectionalChannelInfo_get_enabled(this.ptr);
  45                 return ret;
  46         }
  47
  48         /**
  49          * Whether the channel can be currently used for payments (in this one direction).
  50          */
  51         public void set_enabled(boolean val) {
  52                 bindings.DirectionalChannelInfo_set_enabled(this.ptr, val);
  53         }
  54
  55         /**
  56          * The difference in CLTV values that you must have when routing through this channel.
  57          */
  58         public short get_cltv_expiry_delta() {
  59                 short ret = bindings.DirectionalChannelInfo_get_cltv_expiry_delta(this.ptr);
  60                 return ret;
  61         }
  62
  63         /**
  64          * The difference in CLTV values that you must have when routing through this channel.
  65          */
  66         public void set_cltv_expiry_delta(short val) {
  67                 bindings.DirectionalChannelInfo_set_cltv_expiry_delta(this.ptr, val);
  68         }
  69
  70         /**
  71          * The minimum value, which must be relayed to the next hop via the channel
  72          */
  73         public long get_htlc_minimum_msat() {
  74                 long ret = bindings.DirectionalChannelInfo_get_htlc_minimum_msat(this.ptr);
  75                 return ret;
  76         }
  77
  78         /**
  79          * The minimum value, which must be relayed to the next hop via the channel
  80          */
  81         public void set_htlc_minimum_msat(long val) {
  82                 bindings.DirectionalChannelInfo_set_htlc_minimum_msat(this.ptr, val);
  83         }
  84
  85         /**
  86          * The maximum value which may be relayed to the next hop via the channel.
  87          */
  88         public Option_u64Z get_htlc_maximum_msat() {
  89                 long ret = bindings.DirectionalChannelInfo_get_htlc_maximum_msat(this.ptr);
  90                 if (ret >= 0 && ret <= 4096) { return null; }
  91                 Option_u64Z ret_hu_conv = Option_u64Z.constr_from_ptr(ret);
  92                 ret_hu_conv.ptrs_to.add(this);
  93                 return ret_hu_conv;
  94         }
  95
  96         /**
  97          * The maximum value which may be relayed to the next hop via the channel.
  98          */
  99         public void set_htlc_maximum_msat(Option_u64Z val) {
 100                 bindings.DirectionalChannelInfo_set_htlc_maximum_msat(this.ptr, val.ptr);
 101         }
 102
 103         /**
 104          * Fees charged when the channel is used for routing
 105          */
 106         public RoutingFees get_fees() {
 107                 long ret = bindings.DirectionalChannelInfo_get_fees(this.ptr);
 108                 if (ret >= 0 && ret <= 4096) { return null; }
 109                 RoutingFees ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new RoutingFees(null, ret); }
 110                 ret_hu_conv.ptrs_to.add(this);
 111                 return ret_hu_conv;
 112         }
 113
 114         /**
 115          * Fees charged when the channel is used for routing
 116          */
 117         public void set_fees(RoutingFees val) {
 118                 bindings.DirectionalChannelInfo_set_fees(this.ptr, val == null ? 0 : val.ptr & ~1);
 119         }
 120
 121         /**
 122          * Most recent update for the channel received from the network
 123          * Mostly redundant with the data we store in fields explicitly.
 124          * Everything else is useful only for sending out for initial routing sync.
 125          * Not stored if contains excess data to prevent DoS.
 126          *
 127          * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 128          */
 129         @Nullable
 130         public ChannelUpdate get_last_update_message() {
 131                 long ret = bindings.DirectionalChannelInfo_get_last_update_message(this.ptr);
 132                 if (ret >= 0 && ret <= 4096) { return null; }
 133                 ChannelUpdate ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelUpdate(null, ret); }
 134                 ret_hu_conv.ptrs_to.add(this);
 135                 return ret_hu_conv;
 136         }
 137
 138         /**
 139          * Most recent update for the channel received from the network
 140          * Mostly redundant with the data we store in fields explicitly.
 141          * Everything else is useful only for sending out for initial routing sync.
 142          * Not stored if contains excess data to prevent DoS.
 143          *
 144          * Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
 145          */
 146         public void set_last_update_message(@Nullable ChannelUpdate val) {
 147                 bindings.DirectionalChannelInfo_set_last_update_message(this.ptr, val == null ? 0 : val.ptr & ~1);
 148         }
 149
 150         /**
 151          * Constructs a new DirectionalChannelInfo given each field
 152          */
 153         public static DirectionalChannelInfo of(int last_update_arg, boolean enabled_arg, short cltv_expiry_delta_arg, long htlc_minimum_msat_arg, Option_u64Z htlc_maximum_msat_arg, RoutingFees fees_arg, ChannelUpdate last_update_message_arg) {
 154                 long ret = bindings.DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg.ptr, fees_arg == null ? 0 : fees_arg.ptr & ~1, last_update_message_arg == null ? 0 : last_update_message_arg.ptr & ~1);
 155                 if (ret >= 0 && ret <= 4096) { return null; }
 156                 DirectionalChannelInfo ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new DirectionalChannelInfo(null, ret); }
 157                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 158                 return ret_hu_conv;
 159         }
 160
 161         long clone_ptr() {
 162                 long ret = bindings.DirectionalChannelInfo_clone_ptr(this.ptr);
 163                 return ret;
 164         }
 165
 166         /**
 167          * Creates a copy of the DirectionalChannelInfo
 168          */
 169         public DirectionalChannelInfo clone() {
 170                 long ret = bindings.DirectionalChannelInfo_clone(this.ptr);
 171                 if (ret >= 0 && ret <= 4096) { return null; }
 172                 DirectionalChannelInfo ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new DirectionalChannelInfo(null, ret); }
 173                 ret_hu_conv.ptrs_to.add(this);
 174                 return ret_hu_conv;
 175         }
 176
 177         /**
 178          * Serialize the DirectionalChannelInfo object into a byte array which can be read by DirectionalChannelInfo_read
 179          */
 180         public byte[] write() {
 181                 byte[] ret = bindings.DirectionalChannelInfo_write(this.ptr);
 182                 return ret;
 183         }
 184
 185         /**
 186          * Read a DirectionalChannelInfo from a byte array, created by DirectionalChannelInfo_write
 187          */
 188         public static Result_DirectionalChannelInfoDecodeErrorZ read(byte[] ser) {
 189                 long ret = bindings.DirectionalChannelInfo_read(ser);
 190                 if (ret >= 0 && ret <= 4096) { return null; }
 191                 Result_DirectionalChannelInfoDecodeErrorZ ret_hu_conv = Result_DirectionalChannelInfoDecodeErrorZ.constr_from_ptr(ret);
 192                 return ret_hu_conv;
 193         }
 194
 195 }