_ Git - ldk-java/blob - ts/structs/PaymentError.ts

   1
   2 import CommonBase from './CommonBase';
   3 import * as bindings from '../bindings' // TODO: figure out location
   4
   5 export default class PaymentError extends CommonBase {
   6         protected constructor(_dummy: object, ptr: number) { super(ptr); }
   7         protected finalize() {
   8                 super.finalize();
   9                 if (this.ptr != 0) { bindings.PaymentError_free(this.ptr); }
  10         }
  11         static constr_from_ptr(ptr: number): PaymentError {
  12                 const raw_val: bindings.LDKPaymentError = bindings.LDKPaymentError_ref_from_ptr(ptr);
  13                 if (raw_val instanceof bindings.LDKPaymentError.Invoice) {
  14                         return new Invoice(this.ptr, raw_val);
  15                 }
  16                 if (raw_val instanceof bindings.LDKPaymentError.Routing) {
  17                         return new Routing(this.ptr, raw_val);
  18                 }
  19                 if (raw_val instanceof bindings.LDKPaymentError.Sending) {
  20                         return new Sending(this.ptr, raw_val);
  21                 }
  22                 throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
  23         }
  24
  25 }
  26 export class Invoice extends PaymentError {
  27         public invoice: String;
  28         private constructor(ptr: number, obj: bindings.LDKPaymentError.Invoice) {
  29                 super(null, ptr);
  30                 this.invoice = obj.invoice;
  31         }
  32 }
  33 export class Routing extends PaymentError {
  34         public routing: LightningError;
  35         private constructor(ptr: number, obj: bindings.LDKPaymentError.Routing) {
  36                 super(null, ptr);
  37                 const routing: number = obj.routing;
  38                 const routing_hu_conv: LightningError = new LightningError(null, routing);
  39                         routing_hu_conv.ptrs_to.add(this);
  40                 this.routing = routing_hu_conv;
  41         }
  42 }
  43 export class Sending extends PaymentError {
  44         public sending: PaymentSendFailure;
  45         private constructor(ptr: number, obj: bindings.LDKPaymentError.Sending) {
  46                 super(null, ptr);
  47                 const sending: number = obj.sending;
  48                 PaymentSendFailure sending_hu_conv = PaymentSendFailure.constr_from_ptr(sending);
  49                         sending_hu_conv.ptrs_to.add(this);
  50                 this.sending = sending_hu_conv;
  51         }
  52 }
  53         public PaymentError clone() {
  54                 number ret = bindings.PaymentError_clone(this.ptr);
  55                 PaymentError ret_hu_conv = PaymentError.constr_from_ptr(ret);
  56                 ret_hu_conv.ptrs_to.add(this);
  57                 return ret_hu_conv;
  58         }
  59
  60         public static PaymentError constructor_invoice(String a) {
  61                 number ret = bindings.PaymentError_invoice(a);
  62                 PaymentError ret_hu_conv = PaymentError.constr_from_ptr(ret);
  63                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  64                 return ret_hu_conv;
  65         }
  66
  67         public static PaymentError constructor_routing(LightningError a) {
  68                 number ret = bindings.PaymentError_routing(a == null ? 0 : a.ptr & ~1);
  69                 PaymentError ret_hu_conv = PaymentError.constr_from_ptr(ret);
  70                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  71                 return ret_hu_conv;
  72         }
  73
  74         public static PaymentError constructor_sending(PaymentSendFailure a) {
  75                 number ret = bindings.PaymentError_sending(a.ptr);
  76                 PaymentError ret_hu_conv = PaymentError.constr_from_ptr(ret);
  77                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  78                 return ret_hu_conv;
  79         }
  80
  81 }