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

   1
   2
   3 import CommonBase from './CommonBase';
   4 import * as bindings from '../bindings' // TODO: figure out location
   5
   6
   7
   8             export class Type extends CommonBase {
   9
  10                 bindings_instance?: bindings.LDKType;
  11
  12                 constructor(ptr?: number, arg?: bindings.LDKType) {
  13                     if (Number.isFinite(ptr)) {
  14                                         super(ptr);
  15                                         this.bindings_instance = null;
  16                                     } else {
  17                                         // TODO: private constructor instantiation
  18                                         super(bindings.LDKType_new(arg));
  19                                         this.ptrs_to.push(arg);
  20
  21                                     }
  22                 }
  23
  24                 protected finalize() {
  25                     if (this.ptr != 0) {
  26                         bindings.Type_free(this.ptr);
  27                     }
  28                     super.finalize();
  29                 }
  30
  31                 static new_impl(arg: TypeInterface): Type {
  32                     const impl_holder: LDKTypeHolder = new LDKTypeHolder();
  33                     let structImplementation = <bindings.LDKType>{
  34                         // todo: in-line interface filling
  35                         type_id (): number {
  36                                                         number ret = arg.type_id();
  37                                 return ret;
  38                                                 },
  39
  40                                                 debug_str (): String {
  41                                                         String ret = arg.debug_str();
  42                                 return ret;
  43                                                 },
  44
  45                                                 write (): Uint8Array {
  46                                                         Uint8Array ret = arg.write();
  47                                 return ret;
  48                                                 },
  49
  50
  51                     };
  52                     impl_holder.held = new Type (null, structImplementation);
  53                 }
  54             }
  55
  56             export interface TypeInterface {
  57                 type_id(): number;
  58                                 debug_str(): String;
  59                                 write(): Uint8Array;
  60
  61             }
  62
  63             class LDKTypeHolder {
  64                 held: Type;
  65             }
  66         public number type_id() {
  67                 number ret = bindings.Type_type_id(this.ptr);
  68                 return ret;
  69         }
  70
  71         public String debug_str() {
  72                 String ret = bindings.Type_debug_str(this.ptr);
  73                 return ret;
  74         }
  75
  76         public Uint8Array write() {
  77                 Uint8Array ret = bindings.Type_write(this.ptr);
  78                 return ret;
  79         }
  80
  81         public number clone_ptr() {
  82                 number ret = bindings.Type_clone_ptr(this.ptr);
  83                 return ret;
  84         }
  85
  86         public Type clone() {
  87                 number ret = bindings.Type_clone(this.ptr);
  88                 Type ret_hu_conv = new Type(null, ret);
  89                 ret_hu_conv.ptrs_to.add(this);
  90                 return ret_hu_conv;
  91         }
  92
  93 }