_ Git - ldk-java/blob - src/main/java/org/ldk/structs/InitFeatures.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  * Features used within an `init` message.
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class InitFeatures extends CommonBase {
  16         InitFeatures(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.InitFeatures_free(ptr); }
  21         }
  22
  23         /**
  24          * Checks if two InitFeaturess contain equal inner contents.
  25          * This ignores pointers and is_owned flags and looks at the values in fields.
  26          * Two objects with NULL inner values will be considered "equal" here.
  27          */
  28         public boolean eq(InitFeatures b) {
  29                 boolean ret = bindings.InitFeatures_eq(this.ptr, b == null ? 0 : b.ptr);
  30                 Reference.reachabilityFence(this);
  31                 Reference.reachabilityFence(b);
  32                 if (this != null) { this.ptrs_to.add(b); };
  33                 return ret;
  34         }
  35
  36         @Override public boolean equals(Object o) {
  37                 if (!(o instanceof InitFeatures)) return false;
  38                 return this.eq((InitFeatures)o);
  39         }
  40         long clone_ptr() {
  41                 long ret = bindings.InitFeatures_clone_ptr(this.ptr);
  42                 Reference.reachabilityFence(this);
  43                 return ret;
  44         }
  45
  46         /**
  47          * Creates a copy of the InitFeatures
  48          */
  49         public InitFeatures clone() {
  50                 long ret = bindings.InitFeatures_clone(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 if (ret >= 0 && ret <= 4096) { return null; }
  53                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  54                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
  55                 return ret_hu_conv;
  56         }
  57
  58         /**
  59          * Create a blank Features with no features set
  60          */
  61         public static InitFeatures empty() {
  62                 long ret = bindings.InitFeatures_empty();
  63                 if (ret >= 0 && ret <= 4096) { return null; }
  64                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  65                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  66                 return ret_hu_conv;
  67         }
  68
  69         /**
  70          * Creates a Features with the bits set which are known by the implementation
  71          */
  72         public static InitFeatures known() {
  73                 long ret = bindings.InitFeatures_known();
  74                 if (ret >= 0 && ret <= 4096) { return null; }
  75                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  76                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  77                 return ret_hu_conv;
  78         }
  79
  80         /**
  81          * Returns true if this `Features` object contains unknown feature flags which are set as
  82          * \"required\".
  83          */
  84         public boolean requires_unknown_bits() {
  85                 boolean ret = bindings.InitFeatures_requires_unknown_bits(this.ptr);
  86                 Reference.reachabilityFence(this);
  87                 return ret;
  88         }
  89
  90         /**
  91          * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
  92          */
  93         public byte[] write() {
  94                 byte[] ret = bindings.InitFeatures_write(this.ptr);
  95                 Reference.reachabilityFence(this);
  96                 return ret;
  97         }
  98
  99         /**
 100          * Read a InitFeatures from a byte array, created by InitFeatures_write
 101          */
 102         public static Result_InitFeaturesDecodeErrorZ read(byte[] ser) {
 103                 long ret = bindings.InitFeatures_read(ser);
 104                 Reference.reachabilityFence(ser);
 105                 if (ret >= 0 && ret <= 4096) { return null; }
 106                 Result_InitFeaturesDecodeErrorZ ret_hu_conv = Result_InitFeaturesDecodeErrorZ.constr_from_ptr(ret);
 107                 return ret_hu_conv;
 108         }
 109
 110         /**
 111          * Set this feature as optional.
 112          */
 113         public void set_data_loss_protect_optional() {
 114                 bindings.InitFeatures_set_data_loss_protect_optional(this.ptr);
 115                 Reference.reachabilityFence(this);
 116         }
 117
 118         /**
 119          * Set this feature as required.
 120          */
 121         public void set_data_loss_protect_required() {
 122                 bindings.InitFeatures_set_data_loss_protect_required(this.ptr);
 123                 Reference.reachabilityFence(this);
 124         }
 125
 126         /**
 127          * Checks if this feature is supported.
 128          */
 129         public boolean supports_data_loss_protect() {
 130                 boolean ret = bindings.InitFeatures_supports_data_loss_protect(this.ptr);
 131                 Reference.reachabilityFence(this);
 132                 return ret;
 133         }
 134
 135         /**
 136          * Checks if this feature is required.
 137          */
 138         public boolean requires_data_loss_protect() {
 139                 boolean ret = bindings.InitFeatures_requires_data_loss_protect(this.ptr);
 140                 Reference.reachabilityFence(this);
 141                 return ret;
 142         }
 143
 144         /**
 145          * Set this feature as optional.
 146          */
 147         public void set_initial_routing_sync_optional() {
 148                 bindings.InitFeatures_set_initial_routing_sync_optional(this.ptr);
 149                 Reference.reachabilityFence(this);
 150         }
 151
 152         /**
 153          * Set this feature as required.
 154          */
 155         public void set_initial_routing_sync_required() {
 156                 bindings.InitFeatures_set_initial_routing_sync_required(this.ptr);
 157                 Reference.reachabilityFence(this);
 158         }
 159
 160         /**
 161          * Checks if this feature is supported.
 162          */
 163         public boolean initial_routing_sync() {
 164                 boolean ret = bindings.InitFeatures_initial_routing_sync(this.ptr);
 165                 Reference.reachabilityFence(this);
 166                 return ret;
 167         }
 168
 169         /**
 170          * Set this feature as optional.
 171          */
 172         public void set_upfront_shutdown_script_optional() {
 173                 bindings.InitFeatures_set_upfront_shutdown_script_optional(this.ptr);
 174                 Reference.reachabilityFence(this);
 175         }
 176
 177         /**
 178          * Set this feature as required.
 179          */
 180         public void set_upfront_shutdown_script_required() {
 181                 bindings.InitFeatures_set_upfront_shutdown_script_required(this.ptr);
 182                 Reference.reachabilityFence(this);
 183         }
 184
 185         /**
 186          * Checks if this feature is supported.
 187          */
 188         public boolean supports_upfront_shutdown_script() {
 189                 boolean ret = bindings.InitFeatures_supports_upfront_shutdown_script(this.ptr);
 190                 Reference.reachabilityFence(this);
 191                 return ret;
 192         }
 193
 194         /**
 195          * Checks if this feature is required.
 196          */
 197         public boolean requires_upfront_shutdown_script() {
 198                 boolean ret = bindings.InitFeatures_requires_upfront_shutdown_script(this.ptr);
 199                 Reference.reachabilityFence(this);
 200                 return ret;
 201         }
 202
 203         /**
 204          * Set this feature as optional.
 205          */
 206         public void set_gossip_queries_optional() {
 207                 bindings.InitFeatures_set_gossip_queries_optional(this.ptr);
 208                 Reference.reachabilityFence(this);
 209         }
 210
 211         /**
 212          * Set this feature as required.
 213          */
 214         public void set_gossip_queries_required() {
 215                 bindings.InitFeatures_set_gossip_queries_required(this.ptr);
 216                 Reference.reachabilityFence(this);
 217         }
 218
 219         /**
 220          * Checks if this feature is supported.
 221          */
 222         public boolean supports_gossip_queries() {
 223                 boolean ret = bindings.InitFeatures_supports_gossip_queries(this.ptr);
 224                 Reference.reachabilityFence(this);
 225                 return ret;
 226         }
 227
 228         /**
 229          * Checks if this feature is required.
 230          */
 231         public boolean requires_gossip_queries() {
 232                 boolean ret = bindings.InitFeatures_requires_gossip_queries(this.ptr);
 233                 Reference.reachabilityFence(this);
 234                 return ret;
 235         }
 236
 237         /**
 238          * Set this feature as optional.
 239          */
 240         public void set_variable_length_onion_optional() {
 241                 bindings.InitFeatures_set_variable_length_onion_optional(this.ptr);
 242                 Reference.reachabilityFence(this);
 243         }
 244
 245         /**
 246          * Set this feature as required.
 247          */
 248         public void set_variable_length_onion_required() {
 249                 bindings.InitFeatures_set_variable_length_onion_required(this.ptr);
 250                 Reference.reachabilityFence(this);
 251         }
 252
 253         /**
 254          * Checks if this feature is supported.
 255          */
 256         public boolean supports_variable_length_onion() {
 257                 boolean ret = bindings.InitFeatures_supports_variable_length_onion(this.ptr);
 258                 Reference.reachabilityFence(this);
 259                 return ret;
 260         }
 261
 262         /**
 263          * Checks if this feature is required.
 264          */
 265         public boolean requires_variable_length_onion() {
 266                 boolean ret = bindings.InitFeatures_requires_variable_length_onion(this.ptr);
 267                 Reference.reachabilityFence(this);
 268                 return ret;
 269         }
 270
 271         /**
 272          * Set this feature as optional.
 273          */
 274         public void set_static_remote_key_optional() {
 275                 bindings.InitFeatures_set_static_remote_key_optional(this.ptr);
 276                 Reference.reachabilityFence(this);
 277         }
 278
 279         /**
 280          * Set this feature as required.
 281          */
 282         public void set_static_remote_key_required() {
 283                 bindings.InitFeatures_set_static_remote_key_required(this.ptr);
 284                 Reference.reachabilityFence(this);
 285         }
 286
 287         /**
 288          * Checks if this feature is supported.
 289          */
 290         public boolean supports_static_remote_key() {
 291                 boolean ret = bindings.InitFeatures_supports_static_remote_key(this.ptr);
 292                 Reference.reachabilityFence(this);
 293                 return ret;
 294         }
 295
 296         /**
 297          * Checks if this feature is required.
 298          */
 299         public boolean requires_static_remote_key() {
 300                 boolean ret = bindings.InitFeatures_requires_static_remote_key(this.ptr);
 301                 Reference.reachabilityFence(this);
 302                 return ret;
 303         }
 304
 305         /**
 306          * Set this feature as optional.
 307          */
 308         public void set_payment_secret_optional() {
 309                 bindings.InitFeatures_set_payment_secret_optional(this.ptr);
 310                 Reference.reachabilityFence(this);
 311         }
 312
 313         /**
 314          * Set this feature as required.
 315          */
 316         public void set_payment_secret_required() {
 317                 bindings.InitFeatures_set_payment_secret_required(this.ptr);
 318                 Reference.reachabilityFence(this);
 319         }
 320
 321         /**
 322          * Checks if this feature is supported.
 323          */
 324         public boolean supports_payment_secret() {
 325                 boolean ret = bindings.InitFeatures_supports_payment_secret(this.ptr);
 326                 Reference.reachabilityFence(this);
 327                 return ret;
 328         }
 329
 330         /**
 331          * Checks if this feature is required.
 332          */
 333         public boolean requires_payment_secret() {
 334                 boolean ret = bindings.InitFeatures_requires_payment_secret(this.ptr);
 335                 Reference.reachabilityFence(this);
 336                 return ret;
 337         }
 338
 339         /**
 340          * Set this feature as optional.
 341          */
 342         public void set_basic_mpp_optional() {
 343                 bindings.InitFeatures_set_basic_mpp_optional(this.ptr);
 344                 Reference.reachabilityFence(this);
 345         }
 346
 347         /**
 348          * Set this feature as required.
 349          */
 350         public void set_basic_mpp_required() {
 351                 bindings.InitFeatures_set_basic_mpp_required(this.ptr);
 352                 Reference.reachabilityFence(this);
 353         }
 354
 355         /**
 356          * Checks if this feature is supported.
 357          */
 358         public boolean supports_basic_mpp() {
 359                 boolean ret = bindings.InitFeatures_supports_basic_mpp(this.ptr);
 360                 Reference.reachabilityFence(this);
 361                 return ret;
 362         }
 363
 364         /**
 365          * Checks if this feature is required.
 366          */
 367         public boolean requires_basic_mpp() {
 368                 boolean ret = bindings.InitFeatures_requires_basic_mpp(this.ptr);
 369                 Reference.reachabilityFence(this);
 370                 return ret;
 371         }
 372
 373         /**
 374          * Set this feature as optional.
 375          */
 376         public void set_wumbo_optional() {
 377                 bindings.InitFeatures_set_wumbo_optional(this.ptr);
 378                 Reference.reachabilityFence(this);
 379         }
 380
 381         /**
 382          * Set this feature as required.
 383          */
 384         public void set_wumbo_required() {
 385                 bindings.InitFeatures_set_wumbo_required(this.ptr);
 386                 Reference.reachabilityFence(this);
 387         }
 388
 389         /**
 390          * Checks if this feature is supported.
 391          */
 392         public boolean supports_wumbo() {
 393                 boolean ret = bindings.InitFeatures_supports_wumbo(this.ptr);
 394                 Reference.reachabilityFence(this);
 395                 return ret;
 396         }
 397
 398         /**
 399          * Checks if this feature is required.
 400          */
 401         public boolean requires_wumbo() {
 402                 boolean ret = bindings.InitFeatures_requires_wumbo(this.ptr);
 403                 Reference.reachabilityFence(this);
 404                 return ret;
 405         }
 406
 407         /**
 408          * Set this feature as optional.
 409          */
 410         public void set_shutdown_any_segwit_optional() {
 411                 bindings.InitFeatures_set_shutdown_any_segwit_optional(this.ptr);
 412                 Reference.reachabilityFence(this);
 413         }
 414
 415         /**
 416          * Set this feature as required.
 417          */
 418         public void set_shutdown_any_segwit_required() {
 419                 bindings.InitFeatures_set_shutdown_any_segwit_required(this.ptr);
 420                 Reference.reachabilityFence(this);
 421         }
 422
 423         /**
 424          * Checks if this feature is supported.
 425          */
 426         public boolean supports_shutdown_anysegwit() {
 427                 boolean ret = bindings.InitFeatures_supports_shutdown_anysegwit(this.ptr);
 428                 Reference.reachabilityFence(this);
 429                 return ret;
 430         }
 431
 432         /**
 433          * Checks if this feature is required.
 434          */
 435         public boolean requires_shutdown_anysegwit() {
 436                 boolean ret = bindings.InitFeatures_requires_shutdown_anysegwit(this.ptr);
 437                 Reference.reachabilityFence(this);
 438                 return ret;
 439         }
 440
 441         /**
 442          * Set this feature as optional.
 443          */
 444         public void set_channel_type_optional() {
 445                 bindings.InitFeatures_set_channel_type_optional(this.ptr);
 446                 Reference.reachabilityFence(this);
 447         }
 448
 449         /**
 450          * Set this feature as required.
 451          */
 452         public void set_channel_type_required() {
 453                 bindings.InitFeatures_set_channel_type_required(this.ptr);
 454                 Reference.reachabilityFence(this);
 455         }
 456
 457         /**
 458          * Checks if this feature is supported.
 459          */
 460         public boolean supports_channel_type() {
 461                 boolean ret = bindings.InitFeatures_supports_channel_type(this.ptr);
 462                 Reference.reachabilityFence(this);
 463                 return ret;
 464         }
 465
 466         /**
 467          * Checks if this feature is required.
 468          */
 469         public boolean requires_channel_type() {
 470                 boolean ret = bindings.InitFeatures_requires_channel_type(this.ptr);
 471                 Reference.reachabilityFence(this);
 472                 return ret;
 473         }
 474
 475         /**
 476          * Set this feature as optional.
 477          */
 478         public void set_scid_privacy_optional() {
 479                 bindings.InitFeatures_set_scid_privacy_optional(this.ptr);
 480                 Reference.reachabilityFence(this);
 481         }
 482
 483         /**
 484          * Set this feature as required.
 485          */
 486         public void set_scid_privacy_required() {
 487                 bindings.InitFeatures_set_scid_privacy_required(this.ptr);
 488                 Reference.reachabilityFence(this);
 489         }
 490
 491         /**
 492          * Checks if this feature is supported.
 493          */
 494         public boolean supports_scid_privacy() {
 495                 boolean ret = bindings.InitFeatures_supports_scid_privacy(this.ptr);
 496                 Reference.reachabilityFence(this);
 497                 return ret;
 498         }
 499
 500         /**
 501          * Checks if this feature is required.
 502          */
 503         public boolean requires_scid_privacy() {
 504                 boolean ret = bindings.InitFeatures_requires_scid_privacy(this.ptr);
 505                 Reference.reachabilityFence(this);
 506                 return ret;
 507         }
 508
 509         /**
 510          * Set this feature as optional.
 511          */
 512         public void set_zero_conf_optional() {
 513                 bindings.InitFeatures_set_zero_conf_optional(this.ptr);
 514                 Reference.reachabilityFence(this);
 515         }
 516
 517         /**
 518          * Set this feature as required.
 519          */
 520         public void set_zero_conf_required() {
 521                 bindings.InitFeatures_set_zero_conf_required(this.ptr);
 522                 Reference.reachabilityFence(this);
 523         }
 524
 525         /**
 526          * Checks if this feature is supported.
 527          */
 528         public boolean supports_zero_conf() {
 529                 boolean ret = bindings.InitFeatures_supports_zero_conf(this.ptr);
 530                 Reference.reachabilityFence(this);
 531                 return ret;
 532         }
 533
 534         /**
 535          * Checks if this feature is required.
 536          */
 537         public boolean requires_zero_conf() {
 538                 boolean ret = bindings.InitFeatures_requires_zero_conf(this.ptr);
 539                 Reference.reachabilityFence(this);
 540                 return ret;
 541         }
 542
 543 }