_ 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(org.ldk.structs.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          * Returns true if this `Features` object contains unknown feature flags which are set as
  71          * \"required\".
  72          */
  73         public boolean requires_unknown_bits() {
  74                 boolean ret = bindings.InitFeatures_requires_unknown_bits(this.ptr);
  75                 Reference.reachabilityFence(this);
  76                 return ret;
  77         }
  78
  79         /**
  80          * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
  81          */
  82         public byte[] write() {
  83                 byte[] ret = bindings.InitFeatures_write(this.ptr);
  84                 Reference.reachabilityFence(this);
  85                 return ret;
  86         }
  87
  88         /**
  89          * Read a InitFeatures from a byte array, created by InitFeatures_write
  90          */
  91         public static Result_InitFeaturesDecodeErrorZ read(byte[] ser) {
  92                 long ret = bindings.InitFeatures_read(ser);
  93                 Reference.reachabilityFence(ser);
  94                 if (ret >= 0 && ret <= 4096) { return null; }
  95                 Result_InitFeaturesDecodeErrorZ ret_hu_conv = Result_InitFeaturesDecodeErrorZ.constr_from_ptr(ret);
  96                 return ret_hu_conv;
  97         }
  98
  99         /**
 100          * Set this feature as optional.
 101          */
 102         public void set_data_loss_protect_optional() {
 103                 bindings.InitFeatures_set_data_loss_protect_optional(this.ptr);
 104                 Reference.reachabilityFence(this);
 105         }
 106
 107         /**
 108          * Set this feature as required.
 109          */
 110         public void set_data_loss_protect_required() {
 111                 bindings.InitFeatures_set_data_loss_protect_required(this.ptr);
 112                 Reference.reachabilityFence(this);
 113         }
 114
 115         /**
 116          * Checks if this feature is supported.
 117          */
 118         public boolean supports_data_loss_protect() {
 119                 boolean ret = bindings.InitFeatures_supports_data_loss_protect(this.ptr);
 120                 Reference.reachabilityFence(this);
 121                 return ret;
 122         }
 123
 124         /**
 125          * Checks if this feature is required.
 126          */
 127         public boolean requires_data_loss_protect() {
 128                 boolean ret = bindings.InitFeatures_requires_data_loss_protect(this.ptr);
 129                 Reference.reachabilityFence(this);
 130                 return ret;
 131         }
 132
 133         /**
 134          * Set this feature as optional.
 135          */
 136         public void set_initial_routing_sync_optional() {
 137                 bindings.InitFeatures_set_initial_routing_sync_optional(this.ptr);
 138                 Reference.reachabilityFence(this);
 139         }
 140
 141         /**
 142          * Set this feature as required.
 143          */
 144         public void set_initial_routing_sync_required() {
 145                 bindings.InitFeatures_set_initial_routing_sync_required(this.ptr);
 146                 Reference.reachabilityFence(this);
 147         }
 148
 149         /**
 150          * Checks if this feature is supported.
 151          */
 152         public boolean initial_routing_sync() {
 153                 boolean ret = bindings.InitFeatures_initial_routing_sync(this.ptr);
 154                 Reference.reachabilityFence(this);
 155                 return ret;
 156         }
 157
 158         /**
 159          * Set this feature as optional.
 160          */
 161         public void set_upfront_shutdown_script_optional() {
 162                 bindings.InitFeatures_set_upfront_shutdown_script_optional(this.ptr);
 163                 Reference.reachabilityFence(this);
 164         }
 165
 166         /**
 167          * Set this feature as required.
 168          */
 169         public void set_upfront_shutdown_script_required() {
 170                 bindings.InitFeatures_set_upfront_shutdown_script_required(this.ptr);
 171                 Reference.reachabilityFence(this);
 172         }
 173
 174         /**
 175          * Checks if this feature is supported.
 176          */
 177         public boolean supports_upfront_shutdown_script() {
 178                 boolean ret = bindings.InitFeatures_supports_upfront_shutdown_script(this.ptr);
 179                 Reference.reachabilityFence(this);
 180                 return ret;
 181         }
 182
 183         /**
 184          * Checks if this feature is required.
 185          */
 186         public boolean requires_upfront_shutdown_script() {
 187                 boolean ret = bindings.InitFeatures_requires_upfront_shutdown_script(this.ptr);
 188                 Reference.reachabilityFence(this);
 189                 return ret;
 190         }
 191
 192         /**
 193          * Set this feature as optional.
 194          */
 195         public void set_gossip_queries_optional() {
 196                 bindings.InitFeatures_set_gossip_queries_optional(this.ptr);
 197                 Reference.reachabilityFence(this);
 198         }
 199
 200         /**
 201          * Set this feature as required.
 202          */
 203         public void set_gossip_queries_required() {
 204                 bindings.InitFeatures_set_gossip_queries_required(this.ptr);
 205                 Reference.reachabilityFence(this);
 206         }
 207
 208         /**
 209          * Checks if this feature is supported.
 210          */
 211         public boolean supports_gossip_queries() {
 212                 boolean ret = bindings.InitFeatures_supports_gossip_queries(this.ptr);
 213                 Reference.reachabilityFence(this);
 214                 return ret;
 215         }
 216
 217         /**
 218          * Checks if this feature is required.
 219          */
 220         public boolean requires_gossip_queries() {
 221                 boolean ret = bindings.InitFeatures_requires_gossip_queries(this.ptr);
 222                 Reference.reachabilityFence(this);
 223                 return ret;
 224         }
 225
 226         /**
 227          * Set this feature as optional.
 228          */
 229         public void set_variable_length_onion_optional() {
 230                 bindings.InitFeatures_set_variable_length_onion_optional(this.ptr);
 231                 Reference.reachabilityFence(this);
 232         }
 233
 234         /**
 235          * Set this feature as required.
 236          */
 237         public void set_variable_length_onion_required() {
 238                 bindings.InitFeatures_set_variable_length_onion_required(this.ptr);
 239                 Reference.reachabilityFence(this);
 240         }
 241
 242         /**
 243          * Checks if this feature is supported.
 244          */
 245         public boolean supports_variable_length_onion() {
 246                 boolean ret = bindings.InitFeatures_supports_variable_length_onion(this.ptr);
 247                 Reference.reachabilityFence(this);
 248                 return ret;
 249         }
 250
 251         /**
 252          * Checks if this feature is required.
 253          */
 254         public boolean requires_variable_length_onion() {
 255                 boolean ret = bindings.InitFeatures_requires_variable_length_onion(this.ptr);
 256                 Reference.reachabilityFence(this);
 257                 return ret;
 258         }
 259
 260         /**
 261          * Set this feature as optional.
 262          */
 263         public void set_static_remote_key_optional() {
 264                 bindings.InitFeatures_set_static_remote_key_optional(this.ptr);
 265                 Reference.reachabilityFence(this);
 266         }
 267
 268         /**
 269          * Set this feature as required.
 270          */
 271         public void set_static_remote_key_required() {
 272                 bindings.InitFeatures_set_static_remote_key_required(this.ptr);
 273                 Reference.reachabilityFence(this);
 274         }
 275
 276         /**
 277          * Checks if this feature is supported.
 278          */
 279         public boolean supports_static_remote_key() {
 280                 boolean ret = bindings.InitFeatures_supports_static_remote_key(this.ptr);
 281                 Reference.reachabilityFence(this);
 282                 return ret;
 283         }
 284
 285         /**
 286          * Checks if this feature is required.
 287          */
 288         public boolean requires_static_remote_key() {
 289                 boolean ret = bindings.InitFeatures_requires_static_remote_key(this.ptr);
 290                 Reference.reachabilityFence(this);
 291                 return ret;
 292         }
 293
 294         /**
 295          * Set this feature as optional.
 296          */
 297         public void set_payment_secret_optional() {
 298                 bindings.InitFeatures_set_payment_secret_optional(this.ptr);
 299                 Reference.reachabilityFence(this);
 300         }
 301
 302         /**
 303          * Set this feature as required.
 304          */
 305         public void set_payment_secret_required() {
 306                 bindings.InitFeatures_set_payment_secret_required(this.ptr);
 307                 Reference.reachabilityFence(this);
 308         }
 309
 310         /**
 311          * Checks if this feature is supported.
 312          */
 313         public boolean supports_payment_secret() {
 314                 boolean ret = bindings.InitFeatures_supports_payment_secret(this.ptr);
 315                 Reference.reachabilityFence(this);
 316                 return ret;
 317         }
 318
 319         /**
 320          * Checks if this feature is required.
 321          */
 322         public boolean requires_payment_secret() {
 323                 boolean ret = bindings.InitFeatures_requires_payment_secret(this.ptr);
 324                 Reference.reachabilityFence(this);
 325                 return ret;
 326         }
 327
 328         /**
 329          * Set this feature as optional.
 330          */
 331         public void set_basic_mpp_optional() {
 332                 bindings.InitFeatures_set_basic_mpp_optional(this.ptr);
 333                 Reference.reachabilityFence(this);
 334         }
 335
 336         /**
 337          * Set this feature as required.
 338          */
 339         public void set_basic_mpp_required() {
 340                 bindings.InitFeatures_set_basic_mpp_required(this.ptr);
 341                 Reference.reachabilityFence(this);
 342         }
 343
 344         /**
 345          * Checks if this feature is supported.
 346          */
 347         public boolean supports_basic_mpp() {
 348                 boolean ret = bindings.InitFeatures_supports_basic_mpp(this.ptr);
 349                 Reference.reachabilityFence(this);
 350                 return ret;
 351         }
 352
 353         /**
 354          * Checks if this feature is required.
 355          */
 356         public boolean requires_basic_mpp() {
 357                 boolean ret = bindings.InitFeatures_requires_basic_mpp(this.ptr);
 358                 Reference.reachabilityFence(this);
 359                 return ret;
 360         }
 361
 362         /**
 363          * Set this feature as optional.
 364          */
 365         public void set_wumbo_optional() {
 366                 bindings.InitFeatures_set_wumbo_optional(this.ptr);
 367                 Reference.reachabilityFence(this);
 368         }
 369
 370         /**
 371          * Set this feature as required.
 372          */
 373         public void set_wumbo_required() {
 374                 bindings.InitFeatures_set_wumbo_required(this.ptr);
 375                 Reference.reachabilityFence(this);
 376         }
 377
 378         /**
 379          * Checks if this feature is supported.
 380          */
 381         public boolean supports_wumbo() {
 382                 boolean ret = bindings.InitFeatures_supports_wumbo(this.ptr);
 383                 Reference.reachabilityFence(this);
 384                 return ret;
 385         }
 386
 387         /**
 388          * Checks if this feature is required.
 389          */
 390         public boolean requires_wumbo() {
 391                 boolean ret = bindings.InitFeatures_requires_wumbo(this.ptr);
 392                 Reference.reachabilityFence(this);
 393                 return ret;
 394         }
 395
 396         /**
 397          * Set this feature as optional.
 398          */
 399         public void set_shutdown_any_segwit_optional() {
 400                 bindings.InitFeatures_set_shutdown_any_segwit_optional(this.ptr);
 401                 Reference.reachabilityFence(this);
 402         }
 403
 404         /**
 405          * Set this feature as required.
 406          */
 407         public void set_shutdown_any_segwit_required() {
 408                 bindings.InitFeatures_set_shutdown_any_segwit_required(this.ptr);
 409                 Reference.reachabilityFence(this);
 410         }
 411
 412         /**
 413          * Checks if this feature is supported.
 414          */
 415         public boolean supports_shutdown_anysegwit() {
 416                 boolean ret = bindings.InitFeatures_supports_shutdown_anysegwit(this.ptr);
 417                 Reference.reachabilityFence(this);
 418                 return ret;
 419         }
 420
 421         /**
 422          * Checks if this feature is required.
 423          */
 424         public boolean requires_shutdown_anysegwit() {
 425                 boolean ret = bindings.InitFeatures_requires_shutdown_anysegwit(this.ptr);
 426                 Reference.reachabilityFence(this);
 427                 return ret;
 428         }
 429
 430         /**
 431          * Set this feature as optional.
 432          */
 433         public void set_onion_messages_optional() {
 434                 bindings.InitFeatures_set_onion_messages_optional(this.ptr);
 435                 Reference.reachabilityFence(this);
 436         }
 437
 438         /**
 439          * Set this feature as required.
 440          */
 441         public void set_onion_messages_required() {
 442                 bindings.InitFeatures_set_onion_messages_required(this.ptr);
 443                 Reference.reachabilityFence(this);
 444         }
 445
 446         /**
 447          * Checks if this feature is supported.
 448          */
 449         public boolean supports_onion_messages() {
 450                 boolean ret = bindings.InitFeatures_supports_onion_messages(this.ptr);
 451                 Reference.reachabilityFence(this);
 452                 return ret;
 453         }
 454
 455         /**
 456          * Checks if this feature is required.
 457          */
 458         public boolean requires_onion_messages() {
 459                 boolean ret = bindings.InitFeatures_requires_onion_messages(this.ptr);
 460                 Reference.reachabilityFence(this);
 461                 return ret;
 462         }
 463
 464         /**
 465          * Set this feature as optional.
 466          */
 467         public void set_channel_type_optional() {
 468                 bindings.InitFeatures_set_channel_type_optional(this.ptr);
 469                 Reference.reachabilityFence(this);
 470         }
 471
 472         /**
 473          * Set this feature as required.
 474          */
 475         public void set_channel_type_required() {
 476                 bindings.InitFeatures_set_channel_type_required(this.ptr);
 477                 Reference.reachabilityFence(this);
 478         }
 479
 480         /**
 481          * Checks if this feature is supported.
 482          */
 483         public boolean supports_channel_type() {
 484                 boolean ret = bindings.InitFeatures_supports_channel_type(this.ptr);
 485                 Reference.reachabilityFence(this);
 486                 return ret;
 487         }
 488
 489         /**
 490          * Checks if this feature is required.
 491          */
 492         public boolean requires_channel_type() {
 493                 boolean ret = bindings.InitFeatures_requires_channel_type(this.ptr);
 494                 Reference.reachabilityFence(this);
 495                 return ret;
 496         }
 497
 498         /**
 499          * Set this feature as optional.
 500          */
 501         public void set_scid_privacy_optional() {
 502                 bindings.InitFeatures_set_scid_privacy_optional(this.ptr);
 503                 Reference.reachabilityFence(this);
 504         }
 505
 506         /**
 507          * Set this feature as required.
 508          */
 509         public void set_scid_privacy_required() {
 510                 bindings.InitFeatures_set_scid_privacy_required(this.ptr);
 511                 Reference.reachabilityFence(this);
 512         }
 513
 514         /**
 515          * Checks if this feature is supported.
 516          */
 517         public boolean supports_scid_privacy() {
 518                 boolean ret = bindings.InitFeatures_supports_scid_privacy(this.ptr);
 519                 Reference.reachabilityFence(this);
 520                 return ret;
 521         }
 522
 523         /**
 524          * Checks if this feature is required.
 525          */
 526         public boolean requires_scid_privacy() {
 527                 boolean ret = bindings.InitFeatures_requires_scid_privacy(this.ptr);
 528                 Reference.reachabilityFence(this);
 529                 return ret;
 530         }
 531
 532         /**
 533          * Set this feature as optional.
 534          */
 535         public void set_zero_conf_optional() {
 536                 bindings.InitFeatures_set_zero_conf_optional(this.ptr);
 537                 Reference.reachabilityFence(this);
 538         }
 539
 540         /**
 541          * Set this feature as required.
 542          */
 543         public void set_zero_conf_required() {
 544                 bindings.InitFeatures_set_zero_conf_required(this.ptr);
 545                 Reference.reachabilityFence(this);
 546         }
 547
 548         /**
 549          * Checks if this feature is supported.
 550          */
 551         public boolean supports_zero_conf() {
 552                 boolean ret = bindings.InitFeatures_supports_zero_conf(this.ptr);
 553                 Reference.reachabilityFence(this);
 554                 return ret;
 555         }
 556
 557         /**
 558          * Checks if this feature is required.
 559          */
 560         public boolean requires_zero_conf() {
 561                 boolean ret = bindings.InitFeatures_requires_zero_conf(this.ptr);
 562                 Reference.reachabilityFence(this);
 563                 return ret;
 564         }
 565
 566 }