_ Git - ldk-java/blob - src/main/java/org/ldk/structs/ChannelTypeFeatures.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  * Features used within the channel_type field in an OpenChannel message.
  13  *
  14  * A channel is always of some known \"type\", describing the transaction formats used and the exact
  15  * semantics of our interaction with our peer.
  16  *
  17  * Note that because a channel is a specific type which is proposed by the opener and accepted by
  18  * the counterparty, only required features are allowed here.
  19  *
  20  * This is serialized differently from other feature types - it is not prefixed by a length, and
  21  * thus must only appear inside a TLV where its length is known in advance.
  22  */
  23 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  24 public class ChannelTypeFeatures extends CommonBase {
  25         ChannelTypeFeatures(Object _dummy, long ptr) { super(ptr); }
  26         @Override @SuppressWarnings("deprecation")
  27         protected void finalize() throws Throwable {
  28                 super.finalize();
  29                 if (ptr != 0) { bindings.ChannelTypeFeatures_free(ptr); }
  30         }
  31
  32         /**
  33          * Checks if two ChannelTypeFeaturess contain equal inner contents.
  34          * This ignores pointers and is_owned flags and looks at the values in fields.
  35          * Two objects with NULL inner values will be considered "equal" here.
  36          */
  37         public boolean eq(ChannelTypeFeatures b) {
  38                 boolean ret = bindings.ChannelTypeFeatures_eq(this.ptr, b == null ? 0 : b.ptr & ~1);
  39                 Reference.reachabilityFence(this);
  40                 Reference.reachabilityFence(b);
  41                 this.ptrs_to.add(b);
  42                 return ret;
  43         }
  44
  45         @Override public boolean equals(Object o) {
  46                 if (!(o instanceof ChannelTypeFeatures)) return false;
  47                 return this.eq((ChannelTypeFeatures)o);
  48         }
  49         long clone_ptr() {
  50                 long ret = bindings.ChannelTypeFeatures_clone_ptr(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 return ret;
  53         }
  54
  55         /**
  56          * Creates a copy of the ChannelTypeFeatures
  57          */
  58         public ChannelTypeFeatures clone() {
  59                 long ret = bindings.ChannelTypeFeatures_clone(this.ptr);
  60                 Reference.reachabilityFence(this);
  61                 if (ret >= 0 && ret <= 4096) { return null; }
  62                 ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelTypeFeatures(null, ret); }
  63                 ret_hu_conv.ptrs_to.add(this);
  64                 return ret_hu_conv;
  65         }
  66
  67         /**
  68          * Create a blank Features with no features set
  69          */
  70         public static ChannelTypeFeatures empty() {
  71                 long ret = bindings.ChannelTypeFeatures_empty();
  72                 if (ret >= 0 && ret <= 4096) { return null; }
  73                 ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelTypeFeatures(null, ret); }
  74                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  75                 return ret_hu_conv;
  76         }
  77
  78         /**
  79          * Creates a Features with the bits set which are known by the implementation
  80          */
  81         public static ChannelTypeFeatures known() {
  82                 long ret = bindings.ChannelTypeFeatures_known();
  83                 if (ret >= 0 && ret <= 4096) { return null; }
  84                 ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelTypeFeatures(null, ret); }
  85                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  86                 return ret_hu_conv;
  87         }
  88
  89         /**
  90          * Returns true if this `Features` object contains unknown feature flags which are set as
  91          * \"required\".
  92          */
  93         public boolean requires_unknown_bits() {
  94                 boolean ret = bindings.ChannelTypeFeatures_requires_unknown_bits(this.ptr);
  95                 Reference.reachabilityFence(this);
  96                 return ret;
  97         }
  98
  99         /**
 100          * Serialize the ChannelTypeFeatures object into a byte array which can be read by ChannelTypeFeatures_read
 101          */
 102         public byte[] write() {
 103                 byte[] ret = bindings.ChannelTypeFeatures_write(this.ptr);
 104                 Reference.reachabilityFence(this);
 105                 return ret;
 106         }
 107
 108         /**
 109          * Read a ChannelTypeFeatures from a byte array, created by ChannelTypeFeatures_write
 110          */
 111         public static Result_ChannelTypeFeaturesDecodeErrorZ read(byte[] ser) {
 112                 long ret = bindings.ChannelTypeFeatures_read(ser);
 113                 Reference.reachabilityFence(ser);
 114                 if (ret >= 0 && ret <= 4096) { return null; }
 115                 Result_ChannelTypeFeaturesDecodeErrorZ ret_hu_conv = Result_ChannelTypeFeaturesDecodeErrorZ.constr_from_ptr(ret);
 116                 return ret_hu_conv;
 117         }
 118
 119 }