_ Git - ldk-java/blob - src/main/java/org/ldk/structs/ParseError.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  * Errors that indicate what is wrong with the invoice. They have some granularity for debug
  13  * reasons, but should generally result in an \"invalid BOLT11 invoice\" message for the user.
  14  */
  15 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  16 public class ParseError extends CommonBase {
  17         private ParseError(Object _dummy, long ptr) { super(ptr); }
  18         @Override @SuppressWarnings("deprecation")
  19         protected void finalize() throws Throwable {
  20                 super.finalize();
  21                 if (ptr != 0) { bindings.ParseError_free(ptr); }
  22         }
  23         static ParseError constr_from_ptr(long ptr) {
  24                 bindings.LDKParseError raw_val = bindings.LDKParseError_ref_from_ptr(ptr);
  25                 if (raw_val.getClass() == bindings.LDKParseError.Bech32Error.class) {
  26                         return new Bech32Error(ptr, (bindings.LDKParseError.Bech32Error)raw_val);
  27                 }
  28                 if (raw_val.getClass() == bindings.LDKParseError.ParseAmountError.class) {
  29                         return new ParseAmountError(ptr, (bindings.LDKParseError.ParseAmountError)raw_val);
  30                 }
  31                 if (raw_val.getClass() == bindings.LDKParseError.MalformedSignature.class) {
  32                         return new MalformedSignature(ptr, (bindings.LDKParseError.MalformedSignature)raw_val);
  33                 }
  34                 if (raw_val.getClass() == bindings.LDKParseError.BadPrefix.class) {
  35                         return new BadPrefix(ptr, (bindings.LDKParseError.BadPrefix)raw_val);
  36                 }
  37                 if (raw_val.getClass() == bindings.LDKParseError.UnknownCurrency.class) {
  38                         return new UnknownCurrency(ptr, (bindings.LDKParseError.UnknownCurrency)raw_val);
  39                 }
  40                 if (raw_val.getClass() == bindings.LDKParseError.UnknownSiPrefix.class) {
  41                         return new UnknownSiPrefix(ptr, (bindings.LDKParseError.UnknownSiPrefix)raw_val);
  42                 }
  43                 if (raw_val.getClass() == bindings.LDKParseError.MalformedHRP.class) {
  44                         return new MalformedHRP(ptr, (bindings.LDKParseError.MalformedHRP)raw_val);
  45                 }
  46                 if (raw_val.getClass() == bindings.LDKParseError.TooShortDataPart.class) {
  47                         return new TooShortDataPart(ptr, (bindings.LDKParseError.TooShortDataPart)raw_val);
  48                 }
  49                 if (raw_val.getClass() == bindings.LDKParseError.UnexpectedEndOfTaggedFields.class) {
  50                         return new UnexpectedEndOfTaggedFields(ptr, (bindings.LDKParseError.UnexpectedEndOfTaggedFields)raw_val);
  51                 }
  52                 if (raw_val.getClass() == bindings.LDKParseError.DescriptionDecodeError.class) {
  53                         return new DescriptionDecodeError(ptr, (bindings.LDKParseError.DescriptionDecodeError)raw_val);
  54                 }
  55                 if (raw_val.getClass() == bindings.LDKParseError.PaddingError.class) {
  56                         return new PaddingError(ptr, (bindings.LDKParseError.PaddingError)raw_val);
  57                 }
  58                 if (raw_val.getClass() == bindings.LDKParseError.IntegerOverflowError.class) {
  59                         return new IntegerOverflowError(ptr, (bindings.LDKParseError.IntegerOverflowError)raw_val);
  60                 }
  61                 if (raw_val.getClass() == bindings.LDKParseError.InvalidSegWitProgramLength.class) {
  62                         return new InvalidSegWitProgramLength(ptr, (bindings.LDKParseError.InvalidSegWitProgramLength)raw_val);
  63                 }
  64                 if (raw_val.getClass() == bindings.LDKParseError.InvalidPubKeyHashLength.class) {
  65                         return new InvalidPubKeyHashLength(ptr, (bindings.LDKParseError.InvalidPubKeyHashLength)raw_val);
  66                 }
  67                 if (raw_val.getClass() == bindings.LDKParseError.InvalidScriptHashLength.class) {
  68                         return new InvalidScriptHashLength(ptr, (bindings.LDKParseError.InvalidScriptHashLength)raw_val);
  69                 }
  70                 if (raw_val.getClass() == bindings.LDKParseError.InvalidRecoveryId.class) {
  71                         return new InvalidRecoveryId(ptr, (bindings.LDKParseError.InvalidRecoveryId)raw_val);
  72                 }
  73                 if (raw_val.getClass() == bindings.LDKParseError.InvalidSliceLength.class) {
  74                         return new InvalidSliceLength(ptr, (bindings.LDKParseError.InvalidSliceLength)raw_val);
  75                 }
  76                 if (raw_val.getClass() == bindings.LDKParseError.Skip.class) {
  77                         return new Skip(ptr, (bindings.LDKParseError.Skip)raw_val);
  78                 }
  79                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  80         }
  81
  82         public final static class Bech32Error extends ParseError {
  83                 public final org.ldk.structs.Bech32Error bech32_error;
  84                 private Bech32Error(long ptr, bindings.LDKParseError.Bech32Error obj) {
  85                         super(null, ptr);
  86                         long bech32_error = obj.bech32_error;
  87                         org.ldk.structs.Bech32Error bech32_error_hu_conv = org.ldk.structs.Bech32Error.constr_from_ptr(bech32_error);
  88                         bech32_error_hu_conv.ptrs_to.add(this);
  89                         this.bech32_error = bech32_error_hu_conv;
  90                 }
  91         }
  92         public final static class ParseAmountError extends ParseError {
  93                 public final org.ldk.util.UnqualifiedError parse_amount_error;
  94                 private ParseAmountError(long ptr, bindings.LDKParseError.ParseAmountError obj) {
  95                         super(null, ptr);
  96                         int parse_amount_error = obj.parse_amount_error;
  97                         UnqualifiedError parse_amount_error_conv = new UnqualifiedError(parse_amount_error);
  98                         this.parse_amount_error = parse_amount_error_conv;
  99                 }
 100         }
 101         public final static class MalformedSignature extends ParseError {
 102                 public final org.ldk.enums.Secp256k1Error malformed_signature;
 103                 private MalformedSignature(long ptr, bindings.LDKParseError.MalformedSignature obj) {
 104                         super(null, ptr);
 105                         this.malformed_signature = obj.malformed_signature;
 106                 }
 107         }
 108         public final static class BadPrefix extends ParseError {
 109                 private BadPrefix(long ptr, bindings.LDKParseError.BadPrefix obj) {
 110                         super(null, ptr);
 111                 }
 112         }
 113         public final static class UnknownCurrency extends ParseError {
 114                 private UnknownCurrency(long ptr, bindings.LDKParseError.UnknownCurrency obj) {
 115                         super(null, ptr);
 116                 }
 117         }
 118         public final static class UnknownSiPrefix extends ParseError {
 119                 private UnknownSiPrefix(long ptr, bindings.LDKParseError.UnknownSiPrefix obj) {
 120                         super(null, ptr);
 121                 }
 122         }
 123         public final static class MalformedHRP extends ParseError {
 124                 private MalformedHRP(long ptr, bindings.LDKParseError.MalformedHRP obj) {
 125                         super(null, ptr);
 126                 }
 127         }
 128         public final static class TooShortDataPart extends ParseError {
 129                 private TooShortDataPart(long ptr, bindings.LDKParseError.TooShortDataPart obj) {
 130                         super(null, ptr);
 131                 }
 132         }
 133         public final static class UnexpectedEndOfTaggedFields extends ParseError {
 134                 private UnexpectedEndOfTaggedFields(long ptr, bindings.LDKParseError.UnexpectedEndOfTaggedFields obj) {
 135                         super(null, ptr);
 136                 }
 137         }
 138         public final static class DescriptionDecodeError extends ParseError {
 139                 public final org.ldk.util.UnqualifiedError description_decode_error;
 140                 private DescriptionDecodeError(long ptr, bindings.LDKParseError.DescriptionDecodeError obj) {
 141                         super(null, ptr);
 142                         int description_decode_error = obj.description_decode_error;
 143                         UnqualifiedError description_decode_error_conv = new UnqualifiedError(description_decode_error);
 144                         this.description_decode_error = description_decode_error_conv;
 145                 }
 146         }
 147         public final static class PaddingError extends ParseError {
 148                 private PaddingError(long ptr, bindings.LDKParseError.PaddingError obj) {
 149                         super(null, ptr);
 150                 }
 151         }
 152         public final static class IntegerOverflowError extends ParseError {
 153                 private IntegerOverflowError(long ptr, bindings.LDKParseError.IntegerOverflowError obj) {
 154                         super(null, ptr);
 155                 }
 156         }
 157         public final static class InvalidSegWitProgramLength extends ParseError {
 158                 private InvalidSegWitProgramLength(long ptr, bindings.LDKParseError.InvalidSegWitProgramLength obj) {
 159                         super(null, ptr);
 160                 }
 161         }
 162         public final static class InvalidPubKeyHashLength extends ParseError {
 163                 private InvalidPubKeyHashLength(long ptr, bindings.LDKParseError.InvalidPubKeyHashLength obj) {
 164                         super(null, ptr);
 165                 }
 166         }
 167         public final static class InvalidScriptHashLength extends ParseError {
 168                 private InvalidScriptHashLength(long ptr, bindings.LDKParseError.InvalidScriptHashLength obj) {
 169                         super(null, ptr);
 170                 }
 171         }
 172         public final static class InvalidRecoveryId extends ParseError {
 173                 private InvalidRecoveryId(long ptr, bindings.LDKParseError.InvalidRecoveryId obj) {
 174                         super(null, ptr);
 175                 }
 176         }
 177         public final static class InvalidSliceLength extends ParseError {
 178                 public final java.lang.String invalid_slice_length;
 179                 private InvalidSliceLength(long ptr, bindings.LDKParseError.InvalidSliceLength obj) {
 180                         super(null, ptr);
 181                         this.invalid_slice_length = obj.invalid_slice_length;
 182                 }
 183         }
 184         /**
 185          * Not an error, but used internally to signal that a part of the invoice should be ignored
 186          * according to BOLT11
 187          */
 188         public final static class Skip extends ParseError {
 189                 private Skip(long ptr, bindings.LDKParseError.Skip obj) {
 190                         super(null, ptr);
 191                 }
 192         }
 193         long clone_ptr() {
 194                 long ret = bindings.ParseError_clone_ptr(this.ptr);
 195                 Reference.reachabilityFence(this);
 196                 return ret;
 197         }
 198
 199         /**
 200          * Creates a copy of the ParseError
 201          */
 202         public ParseError clone() {
 203                 long ret = bindings.ParseError_clone(this.ptr);
 204                 Reference.reachabilityFence(this);
 205                 if (ret >= 0 && ret <= 4096) { return null; }
 206                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 207                 ret_hu_conv.ptrs_to.add(this);
 208                 return ret_hu_conv;
 209         }
 210
 211         /**
 212          * Utility method to constructs a new Bech32Error-variant ParseError
 213          */
 214         public static ParseError bech32_error(Bech32Error a) {
 215                 long ret = bindings.ParseError_bech32_error(a.ptr);
 216                 Reference.reachabilityFence(a);
 217                 if (ret >= 0 && ret <= 4096) { return null; }
 218                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 219                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 220                 return ret_hu_conv;
 221         }
 222
 223         /**
 224          * Utility method to constructs a new ParseAmountError-variant ParseError
 225          */
 226         public static ParseError parse_amount_error(UnqualifiedError a) {
 227                 long ret = bindings.ParseError_parse_amount_error(0);
 228                 Reference.reachabilityFence(a);
 229                 if (ret >= 0 && ret <= 4096) { return null; }
 230                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 231                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 232                 return ret_hu_conv;
 233         }
 234
 235         /**
 236          * Utility method to constructs a new MalformedSignature-variant ParseError
 237          */
 238         public static ParseError malformed_signature(org.ldk.enums.Secp256k1Error a) {
 239                 long ret = bindings.ParseError_malformed_signature(a);
 240                 Reference.reachabilityFence(a);
 241                 if (ret >= 0 && ret <= 4096) { return null; }
 242                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 243                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 244                 return ret_hu_conv;
 245         }
 246
 247         /**
 248          * Utility method to constructs a new BadPrefix-variant ParseError
 249          */
 250         public static ParseError bad_prefix() {
 251                 long ret = bindings.ParseError_bad_prefix();
 252                 if (ret >= 0 && ret <= 4096) { return null; }
 253                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 254                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 255                 return ret_hu_conv;
 256         }
 257
 258         /**
 259          * Utility method to constructs a new UnknownCurrency-variant ParseError
 260          */
 261         public static ParseError unknown_currency() {
 262                 long ret = bindings.ParseError_unknown_currency();
 263                 if (ret >= 0 && ret <= 4096) { return null; }
 264                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 265                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 266                 return ret_hu_conv;
 267         }
 268
 269         /**
 270          * Utility method to constructs a new UnknownSiPrefix-variant ParseError
 271          */
 272         public static ParseError unknown_si_prefix() {
 273                 long ret = bindings.ParseError_unknown_si_prefix();
 274                 if (ret >= 0 && ret <= 4096) { return null; }
 275                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 276                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 277                 return ret_hu_conv;
 278         }
 279
 280         /**
 281          * Utility method to constructs a new MalformedHRP-variant ParseError
 282          */
 283         public static ParseError malformed_hrp() {
 284                 long ret = bindings.ParseError_malformed_hrp();
 285                 if (ret >= 0 && ret <= 4096) { return null; }
 286                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 287                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 288                 return ret_hu_conv;
 289         }
 290
 291         /**
 292          * Utility method to constructs a new TooShortDataPart-variant ParseError
 293          */
 294         public static ParseError too_short_data_part() {
 295                 long ret = bindings.ParseError_too_short_data_part();
 296                 if (ret >= 0 && ret <= 4096) { return null; }
 297                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 298                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 299                 return ret_hu_conv;
 300         }
 301
 302         /**
 303          * Utility method to constructs a new UnexpectedEndOfTaggedFields-variant ParseError
 304          */
 305         public static ParseError unexpected_end_of_tagged_fields() {
 306                 long ret = bindings.ParseError_unexpected_end_of_tagged_fields();
 307                 if (ret >= 0 && ret <= 4096) { return null; }
 308                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 309                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 310                 return ret_hu_conv;
 311         }
 312
 313         /**
 314          * Utility method to constructs a new DescriptionDecodeError-variant ParseError
 315          */
 316         public static ParseError description_decode_error(UnqualifiedError a) {
 317                 long ret = bindings.ParseError_description_decode_error(0);
 318                 Reference.reachabilityFence(a);
 319                 if (ret >= 0 && ret <= 4096) { return null; }
 320                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 321                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 322                 return ret_hu_conv;
 323         }
 324
 325         /**
 326          * Utility method to constructs a new PaddingError-variant ParseError
 327          */
 328         public static ParseError padding_error() {
 329                 long ret = bindings.ParseError_padding_error();
 330                 if (ret >= 0 && ret <= 4096) { return null; }
 331                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 332                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 333                 return ret_hu_conv;
 334         }
 335
 336         /**
 337          * Utility method to constructs a new IntegerOverflowError-variant ParseError
 338          */
 339         public static ParseError integer_overflow_error() {
 340                 long ret = bindings.ParseError_integer_overflow_error();
 341                 if (ret >= 0 && ret <= 4096) { return null; }
 342                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 343                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 344                 return ret_hu_conv;
 345         }
 346
 347         /**
 348          * Utility method to constructs a new InvalidSegWitProgramLength-variant ParseError
 349          */
 350         public static ParseError invalid_seg_wit_program_length() {
 351                 long ret = bindings.ParseError_invalid_seg_wit_program_length();
 352                 if (ret >= 0 && ret <= 4096) { return null; }
 353                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 354                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 355                 return ret_hu_conv;
 356         }
 357
 358         /**
 359          * Utility method to constructs a new InvalidPubKeyHashLength-variant ParseError
 360          */
 361         public static ParseError invalid_pub_key_hash_length() {
 362                 long ret = bindings.ParseError_invalid_pub_key_hash_length();
 363                 if (ret >= 0 && ret <= 4096) { return null; }
 364                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 365                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 366                 return ret_hu_conv;
 367         }
 368
 369         /**
 370          * Utility method to constructs a new InvalidScriptHashLength-variant ParseError
 371          */
 372         public static ParseError invalid_script_hash_length() {
 373                 long ret = bindings.ParseError_invalid_script_hash_length();
 374                 if (ret >= 0 && ret <= 4096) { return null; }
 375                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 376                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 377                 return ret_hu_conv;
 378         }
 379
 380         /**
 381          * Utility method to constructs a new InvalidRecoveryId-variant ParseError
 382          */
 383         public static ParseError invalid_recovery_id() {
 384                 long ret = bindings.ParseError_invalid_recovery_id();
 385                 if (ret >= 0 && ret <= 4096) { return null; }
 386                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 387                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 388                 return ret_hu_conv;
 389         }
 390
 391         /**
 392          * Utility method to constructs a new InvalidSliceLength-variant ParseError
 393          */
 394         public static ParseError invalid_slice_length(java.lang.String a) {
 395                 long ret = bindings.ParseError_invalid_slice_length(a);
 396                 Reference.reachabilityFence(a);
 397                 if (ret >= 0 && ret <= 4096) { return null; }
 398                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 399                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 400                 return ret_hu_conv;
 401         }
 402
 403         /**
 404          * Utility method to constructs a new Skip-variant ParseError
 405          */
 406         public static ParseError skip() {
 407                 long ret = bindings.ParseError_skip();
 408                 if (ret >= 0 && ret <= 4096) { return null; }
 409                 org.ldk.structs.ParseError ret_hu_conv = org.ldk.structs.ParseError.constr_from_ptr(ret);
 410                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 411                 return ret_hu_conv;
 412         }
 413
 414         /**
 415          * Get the string representation of a ParseError object
 416          */
 417         public String to_str() {
 418                 String ret = bindings.ParseError_to_str(this.ptr);
 419                 Reference.reachabilityFence(this);
 420                 return ret;
 421         }
 422
 423 }