_ Git - ldk-java/blob - src/main/java/org/ldk/structs/Fallback.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  * Fallback address in case no LN payment is possible
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class Fallback extends CommonBase {
  16         private Fallback(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.Fallback_free(ptr); }
  21         }
  22         static Fallback constr_from_ptr(long ptr) {
  23                 bindings.LDKFallback raw_val = bindings.LDKFallback_ref_from_ptr(ptr);
  24                 if (raw_val.getClass() == bindings.LDKFallback.SegWitProgram.class) {
  25                         return new SegWitProgram(ptr, (bindings.LDKFallback.SegWitProgram)raw_val);
  26                 }
  27                 if (raw_val.getClass() == bindings.LDKFallback.PubKeyHash.class) {
  28                         return new PubKeyHash(ptr, (bindings.LDKFallback.PubKeyHash)raw_val);
  29                 }
  30                 if (raw_val.getClass() == bindings.LDKFallback.ScriptHash.class) {
  31                         return new ScriptHash(ptr, (bindings.LDKFallback.ScriptHash)raw_val);
  32                 }
  33                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  34         }
  35
  36         public final static class SegWitProgram extends Fallback {
  37                 public final org.ldk.util.UInt5 version;
  38                 public final byte[] program;
  39                 private SegWitProgram(long ptr, bindings.LDKFallback.SegWitProgram obj) {
  40                         super(null, ptr);
  41                         byte version = obj.version;
  42                         UInt5 version_conv = new UInt5(version);
  43                         this.version = version_conv;
  44                         this.program = obj.program;
  45                 }
  46         }
  47         public final static class PubKeyHash extends Fallback {
  48                 public final byte[] pub_key_hash;
  49                 private PubKeyHash(long ptr, bindings.LDKFallback.PubKeyHash obj) {
  50                         super(null, ptr);
  51                         this.pub_key_hash = obj.pub_key_hash;
  52                 }
  53         }
  54         public final static class ScriptHash extends Fallback {
  55                 public final byte[] script_hash;
  56                 private ScriptHash(long ptr, bindings.LDKFallback.ScriptHash obj) {
  57                         super(null, ptr);
  58                         this.script_hash = obj.script_hash;
  59                 }
  60         }
  61         long clone_ptr() {
  62                 long ret = bindings.Fallback_clone_ptr(this.ptr);
  63                 Reference.reachabilityFence(this);
  64                 return ret;
  65         }
  66
  67         /**
  68          * Creates a copy of the Fallback
  69          */
  70         public Fallback clone() {
  71                 long ret = bindings.Fallback_clone(this.ptr);
  72                 Reference.reachabilityFence(this);
  73                 if (ret >= 0 && ret <= 4096) { return null; }
  74                 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
  75                 ret_hu_conv.ptrs_to.add(this);
  76                 return ret_hu_conv;
  77         }
  78
  79         /**
  80          * Utility method to constructs a new SegWitProgram-variant Fallback
  81          */
  82         public static Fallback seg_wit_program(UInt5 version, byte[] program) {
  83                 long ret = bindings.Fallback_seg_wit_program(version.getVal(), program);
  84                 Reference.reachabilityFence(version);
  85                 Reference.reachabilityFence(program);
  86                 if (ret >= 0 && ret <= 4096) { return null; }
  87                 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
  88                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  89                 return ret_hu_conv;
  90         }
  91
  92         /**
  93          * Utility method to constructs a new PubKeyHash-variant Fallback
  94          */
  95         public static Fallback pub_key_hash(byte[] a) {
  96                 long ret = bindings.Fallback_pub_key_hash(InternalUtils.check_arr_len(a, 20));
  97                 Reference.reachabilityFence(a);
  98                 if (ret >= 0 && ret <= 4096) { return null; }
  99                 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
 100                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 101                 return ret_hu_conv;
 102         }
 103
 104         /**
 105          * Utility method to constructs a new ScriptHash-variant Fallback
 106          */
 107         public static Fallback script_hash(byte[] a) {
 108                 long ret = bindings.Fallback_script_hash(InternalUtils.check_arr_len(a, 20));
 109                 Reference.reachabilityFence(a);
 110                 if (ret >= 0 && ret <= 4096) { return null; }
 111                 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
 112                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 113                 return ret_hu_conv;
 114         }
 115
 116         /**
 117          * Checks if two Fallbacks contain equal inner contents.
 118          */
 119         public long hash() {
 120                 long ret = bindings.Fallback_hash(this.ptr);
 121                 Reference.reachabilityFence(this);
 122                 return ret;
 123         }
 124
 125         @Override public int hashCode() {
 126                 return (int)this.hash();
 127         }
 128         /**
 129          * Checks if two Fallbacks contain equal inner contents.
 130          * This ignores pointers and is_owned flags and looks at the values in fields.
 131          */
 132         public boolean eq(Fallback b) {
 133                 boolean ret = bindings.Fallback_eq(this.ptr, b == null ? 0 : b.ptr & ~1);
 134                 Reference.reachabilityFence(this);
 135                 Reference.reachabilityFence(b);
 136                 return ret;
 137         }
 138
 139         @Override public boolean equals(Object o) {
 140                 if (!(o instanceof Fallback)) return false;
 141                 return this.eq((Fallback)o);
 142         }
 143 }