_ Git - ldk-java/blob - src/main/java/org/ldk/structs/UnsignedGossipMessage.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  * Represents the set of gossip messages that require a signature from a node's identity key.
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class UnsignedGossipMessage extends CommonBase {
  16         private UnsignedGossipMessage(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.UnsignedGossipMessage_free(ptr); }
  21         }
  22         static UnsignedGossipMessage constr_from_ptr(long ptr) {
  23                 bindings.LDKUnsignedGossipMessage raw_val = bindings.LDKUnsignedGossipMessage_ref_from_ptr(ptr);
  24                 if (raw_val.getClass() == bindings.LDKUnsignedGossipMessage.ChannelAnnouncement.class) {
  25                         return new ChannelAnnouncement(ptr, (bindings.LDKUnsignedGossipMessage.ChannelAnnouncement)raw_val);
  26                 }
  27                 if (raw_val.getClass() == bindings.LDKUnsignedGossipMessage.ChannelUpdate.class) {
  28                         return new ChannelUpdate(ptr, (bindings.LDKUnsignedGossipMessage.ChannelUpdate)raw_val);
  29                 }
  30                 if (raw_val.getClass() == bindings.LDKUnsignedGossipMessage.NodeAnnouncement.class) {
  31                         return new NodeAnnouncement(ptr, (bindings.LDKUnsignedGossipMessage.NodeAnnouncement)raw_val);
  32                 }
  33                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  34         }
  35
  36         /**
  37          * An unsigned channel announcement.
  38          */
  39         public final static class ChannelAnnouncement extends UnsignedGossipMessage {
  40                 public final org.ldk.structs.UnsignedChannelAnnouncement channel_announcement;
  41                 private ChannelAnnouncement(long ptr, bindings.LDKUnsignedGossipMessage.ChannelAnnouncement obj) {
  42                         super(null, ptr);
  43                         long channel_announcement = obj.channel_announcement;
  44                         org.ldk.structs.UnsignedChannelAnnouncement channel_announcement_hu_conv = null; if (channel_announcement < 0 || channel_announcement > 4096) { channel_announcement_hu_conv = new org.ldk.structs.UnsignedChannelAnnouncement(null, channel_announcement); }
  45                         if (channel_announcement_hu_conv != null) { channel_announcement_hu_conv.ptrs_to.add(this); };
  46                         this.channel_announcement = channel_announcement_hu_conv;
  47                 }
  48         }
  49         /**
  50          * An unsigned channel update.
  51          */
  52         public final static class ChannelUpdate extends UnsignedGossipMessage {
  53                 public final org.ldk.structs.UnsignedChannelUpdate channel_update;
  54                 private ChannelUpdate(long ptr, bindings.LDKUnsignedGossipMessage.ChannelUpdate obj) {
  55                         super(null, ptr);
  56                         long channel_update = obj.channel_update;
  57                         org.ldk.structs.UnsignedChannelUpdate channel_update_hu_conv = null; if (channel_update < 0 || channel_update > 4096) { channel_update_hu_conv = new org.ldk.structs.UnsignedChannelUpdate(null, channel_update); }
  58                         if (channel_update_hu_conv != null) { channel_update_hu_conv.ptrs_to.add(this); };
  59                         this.channel_update = channel_update_hu_conv;
  60                 }
  61         }
  62         /**
  63          * An unsigned node announcement.
  64          */
  65         public final static class NodeAnnouncement extends UnsignedGossipMessage {
  66                 public final org.ldk.structs.UnsignedNodeAnnouncement node_announcement;
  67                 private NodeAnnouncement(long ptr, bindings.LDKUnsignedGossipMessage.NodeAnnouncement obj) {
  68                         super(null, ptr);
  69                         long node_announcement = obj.node_announcement;
  70                         org.ldk.structs.UnsignedNodeAnnouncement node_announcement_hu_conv = null; if (node_announcement < 0 || node_announcement > 4096) { node_announcement_hu_conv = new org.ldk.structs.UnsignedNodeAnnouncement(null, node_announcement); }
  71                         if (node_announcement_hu_conv != null) { node_announcement_hu_conv.ptrs_to.add(this); };
  72                         this.node_announcement = node_announcement_hu_conv;
  73                 }
  74         }
  75         long clone_ptr() {
  76                 long ret = bindings.UnsignedGossipMessage_clone_ptr(this.ptr);
  77                 Reference.reachabilityFence(this);
  78                 return ret;
  79         }
  80
  81         /**
  82          * Creates a copy of the UnsignedGossipMessage
  83          */
  84         public UnsignedGossipMessage clone() {
  85                 long ret = bindings.UnsignedGossipMessage_clone(this.ptr);
  86                 Reference.reachabilityFence(this);
  87                 if (ret >= 0 && ret <= 4096) { return null; }
  88                 org.ldk.structs.UnsignedGossipMessage ret_hu_conv = org.ldk.structs.UnsignedGossipMessage.constr_from_ptr(ret);
  89                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
  90                 return ret_hu_conv;
  91         }
  92
  93         /**
  94          * Utility method to constructs a new ChannelAnnouncement-variant UnsignedGossipMessage
  95          */
  96         public static UnsignedGossipMessage channel_announcement(org.ldk.structs.UnsignedChannelAnnouncement a) {
  97                 long ret = bindings.UnsignedGossipMessage_channel_announcement(a == null ? 0 : a.ptr);
  98                 Reference.reachabilityFence(a);
  99                 if (ret >= 0 && ret <= 4096) { return null; }
 100                 org.ldk.structs.UnsignedGossipMessage ret_hu_conv = org.ldk.structs.UnsignedGossipMessage.constr_from_ptr(ret);
 101                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 102                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 103                 return ret_hu_conv;
 104         }
 105
 106         /**
 107          * Utility method to constructs a new ChannelUpdate-variant UnsignedGossipMessage
 108          */
 109         public static UnsignedGossipMessage channel_update(org.ldk.structs.UnsignedChannelUpdate a) {
 110                 long ret = bindings.UnsignedGossipMessage_channel_update(a == null ? 0 : a.ptr);
 111                 Reference.reachabilityFence(a);
 112                 if (ret >= 0 && ret <= 4096) { return null; }
 113                 org.ldk.structs.UnsignedGossipMessage ret_hu_conv = org.ldk.structs.UnsignedGossipMessage.constr_from_ptr(ret);
 114                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 115                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 116                 return ret_hu_conv;
 117         }
 118
 119         /**
 120          * Utility method to constructs a new NodeAnnouncement-variant UnsignedGossipMessage
 121          */
 122         public static UnsignedGossipMessage node_announcement(org.ldk.structs.UnsignedNodeAnnouncement a) {
 123                 long ret = bindings.UnsignedGossipMessage_node_announcement(a == null ? 0 : a.ptr);
 124                 Reference.reachabilityFence(a);
 125                 if (ret >= 0 && ret <= 4096) { return null; }
 126                 org.ldk.structs.UnsignedGossipMessage ret_hu_conv = org.ldk.structs.UnsignedGossipMessage.constr_from_ptr(ret);
 127                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 128                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(a); };
 129                 return ret_hu_conv;
 130         }
 131
 132         /**
 133          * Serialize the UnsignedGossipMessage object into a byte array which can be read by UnsignedGossipMessage_read
 134          */
 135         public byte[] write() {
 136                 byte[] ret = bindings.UnsignedGossipMessage_write(this.ptr);
 137                 Reference.reachabilityFence(this);
 138                 return ret;
 139         }
 140
 141 }