_ Git - ldk-java/blob - src/main/java/org/ldk/structs/APIError.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  * Indicates an error on the client's part (usually some variant of attempting to use too-low or
  12  * too-high values)
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class APIError extends CommonBase {
  16         private APIError(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.APIError_free(ptr); }
  21         }
  22         static APIError constr_from_ptr(long ptr) {
  23                 bindings.LDKAPIError raw_val = bindings.LDKAPIError_ref_from_ptr(ptr);
  24                 if (raw_val.getClass() == bindings.LDKAPIError.APIMisuseError.class) {
  25                         return new APIMisuseError(ptr, (bindings.LDKAPIError.APIMisuseError)raw_val);
  26                 }
  27                 if (raw_val.getClass() == bindings.LDKAPIError.FeeRateTooHigh.class) {
  28                         return new FeeRateTooHigh(ptr, (bindings.LDKAPIError.FeeRateTooHigh)raw_val);
  29                 }
  30                 if (raw_val.getClass() == bindings.LDKAPIError.RouteError.class) {
  31                         return new RouteError(ptr, (bindings.LDKAPIError.RouteError)raw_val);
  32                 }
  33                 if (raw_val.getClass() == bindings.LDKAPIError.ChannelUnavailable.class) {
  34                         return new ChannelUnavailable(ptr, (bindings.LDKAPIError.ChannelUnavailable)raw_val);
  35                 }
  36                 if (raw_val.getClass() == bindings.LDKAPIError.MonitorUpdateFailed.class) {
  37                         return new MonitorUpdateFailed(ptr, (bindings.LDKAPIError.MonitorUpdateFailed)raw_val);
  38                 }
  39                 if (raw_val.getClass() == bindings.LDKAPIError.IncompatibleShutdownScript.class) {
  40                         return new IncompatibleShutdownScript(ptr, (bindings.LDKAPIError.IncompatibleShutdownScript)raw_val);
  41                 }
  42                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  43         }
  44
  45         public final static class APIMisuseError extends APIError {
  46                 /**
  47                  * A human-readable error message
  48                 */
  49                 public final String err;
  50                 private APIMisuseError(long ptr, bindings.LDKAPIError.APIMisuseError obj) {
  51                         super(null, ptr);
  52                         this.err = obj.err;
  53                 }
  54         }
  55         public final static class FeeRateTooHigh extends APIError {
  56                 /**
  57                  * A human-readable error message
  58                 */
  59                 public final String err;
  60                 /**
  61                  * The feerate which was too high.
  62                 */
  63                 public final int feerate;
  64                 private FeeRateTooHigh(long ptr, bindings.LDKAPIError.FeeRateTooHigh obj) {
  65                         super(null, ptr);
  66                         this.err = obj.err;
  67                         this.feerate = obj.feerate;
  68                 }
  69         }
  70         public final static class RouteError extends APIError {
  71                 /**
  72                  * A human-readable error message
  73                 */
  74                 public final String err;
  75                 private RouteError(long ptr, bindings.LDKAPIError.RouteError obj) {
  76                         super(null, ptr);
  77                         this.err = obj.err;
  78                 }
  79         }
  80         public final static class ChannelUnavailable extends APIError {
  81                 /**
  82                  * A human-readable error message
  83                 */
  84                 public final String err;
  85                 private ChannelUnavailable(long ptr, bindings.LDKAPIError.ChannelUnavailable obj) {
  86                         super(null, ptr);
  87                         this.err = obj.err;
  88                 }
  89         }
  90         public final static class MonitorUpdateFailed extends APIError {
  91                 private MonitorUpdateFailed(long ptr, bindings.LDKAPIError.MonitorUpdateFailed obj) {
  92                         super(null, ptr);
  93                 }
  94         }
  95         public final static class IncompatibleShutdownScript extends APIError {
  96                 /**
  97                  * The incompatible shutdown script.
  98                 */
  99                 public final ShutdownScript script;
 100                 private IncompatibleShutdownScript(long ptr, bindings.LDKAPIError.IncompatibleShutdownScript obj) {
 101                         super(null, ptr);
 102                         long script = obj.script;
 103                         ShutdownScript script_hu_conv = new ShutdownScript(null, script);
 104                         script_hu_conv.ptrs_to.add(this);
 105                         this.script = script_hu_conv;
 106                 }
 107         }
 108         /**
 109          * Creates a copy of the APIError
 110          */
 111         public APIError clone() {
 112                 long ret = bindings.APIError_clone(this.ptr);
 113                 if (ret < 1024) { return null; }
 114                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 115                 ret_hu_conv.ptrs_to.add(this);
 116                 return ret_hu_conv;
 117         }
 118
 119         /**
 120          * Utility method to constructs a new APIMisuseError-variant APIError
 121          */
 122         public static APIError apimisuse_error(java.lang.String err) {
 123                 long ret = bindings.APIError_apimisuse_error(err);
 124                 if (ret < 1024) { return null; }
 125                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 126                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 127                 return ret_hu_conv;
 128         }
 129
 130         /**
 131          * Utility method to constructs a new FeeRateTooHigh-variant APIError
 132          */
 133         public static APIError fee_rate_too_high(java.lang.String err, int feerate) {
 134                 long ret = bindings.APIError_fee_rate_too_high(err, feerate);
 135                 if (ret < 1024) { return null; }
 136                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 137                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 138                 return ret_hu_conv;
 139         }
 140
 141         /**
 142          * Utility method to constructs a new RouteError-variant APIError
 143          */
 144         public static APIError route_error(java.lang.String err) {
 145                 long ret = bindings.APIError_route_error(err);
 146                 if (ret < 1024) { return null; }
 147                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 148                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 149                 return ret_hu_conv;
 150         }
 151
 152         /**
 153          * Utility method to constructs a new ChannelUnavailable-variant APIError
 154          */
 155         public static APIError channel_unavailable(java.lang.String err) {
 156                 long ret = bindings.APIError_channel_unavailable(err);
 157                 if (ret < 1024) { return null; }
 158                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 159                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 160                 return ret_hu_conv;
 161         }
 162
 163         /**
 164          * Utility method to constructs a new MonitorUpdateFailed-variant APIError
 165          */
 166         public static APIError monitor_update_failed() {
 167                 long ret = bindings.APIError_monitor_update_failed();
 168                 if (ret < 1024) { return null; }
 169                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 170                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 171                 return ret_hu_conv;
 172         }
 173
 174         /**
 175          * Utility method to constructs a new IncompatibleShutdownScript-variant APIError
 176          */
 177         public static APIError incompatible_shutdown_script(ShutdownScript script) {
 178                 long ret = bindings.APIError_incompatible_shutdown_script(script == null ? 0 : script.ptr & ~1);
 179                 if (ret < 1024) { return null; }
 180                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 181                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 182                 ret_hu_conv.ptrs_to.add(script);
 183                 return ret_hu_conv;
 184         }
 185
 186 }