_ Git - ldk-java/blob - src/main/java/org/ldk/structs/MessageSendEvent.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
   8 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
   9 public class MessageSendEvent extends CommonBase {
  10         private MessageSendEvent(Object _dummy, long ptr) { super(ptr); }
  11         long conv_to_c() { assert false; return 0; /* Should only be called on subclasses */ }
  12         static MessageSendEvent constr_from_ptr(long ptr) {
  13                 bindings.LDKMessageSendEvent raw_val = bindings.LDKMessageSendEvent_ref_from_ptr(ptr);
  14                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendAcceptChannel.class) {
  15                         return new SendAcceptChannel(null, ptr);
  16                 }
  17                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendOpenChannel.class) {
  18                         return new SendOpenChannel(null, ptr);
  19                 }
  20                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendFundingCreated.class) {
  21                         return new SendFundingCreated(null, ptr);
  22                 }
  23                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendFundingSigned.class) {
  24                         return new SendFundingSigned(null, ptr);
  25                 }
  26                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendFundingLocked.class) {
  27                         return new SendFundingLocked(null, ptr);
  28                 }
  29                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendAnnouncementSignatures.class) {
  30                         return new SendAnnouncementSignatures(null, ptr);
  31                 }
  32                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.UpdateHTLCs.class) {
  33                         return new UpdateHTLCs(null, ptr);
  34                 }
  35                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendRevokeAndACK.class) {
  36                         return new SendRevokeAndACK(null, ptr);
  37                 }
  38                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendClosingSigned.class) {
  39                         return new SendClosingSigned(null, ptr);
  40                 }
  41                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendShutdown.class) {
  42                         return new SendShutdown(null, ptr);
  43                 }
  44                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelReestablish.class) {
  45                         return new SendChannelReestablish(null, ptr);
  46                 }
  47                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement.class) {
  48                         return new BroadcastChannelAnnouncement(null, ptr);
  49                 }
  50                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement.class) {
  51                         return new BroadcastNodeAnnouncement(null, ptr);
  52                 }
  53                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastChannelUpdate.class) {
  54                         return new BroadcastChannelUpdate(null, ptr);
  55                 }
  56                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.HandleError.class) {
  57                         return new HandleError(null, ptr);
  58                 }
  59                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.PaymentFailureNetworkUpdate.class) {
  60                         return new PaymentFailureNetworkUpdate(null, ptr);
  61                 }
  62                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  63         }
  64
  65         public final static class SendAcceptChannel extends MessageSendEvent {
  66                 public byte[] node_id;
  67                 public AcceptChannel msg;
  68                 private SendAcceptChannel(Object _dummy, long ptr) { super(null, ptr); }
  69                 @Override long conv_to_c() { return 0; /*XXX*/ }
  70         }
  71         public final static class SendOpenChannel extends MessageSendEvent {
  72                 public byte[] node_id;
  73                 public OpenChannel msg;
  74                 private SendOpenChannel(Object _dummy, long ptr) { super(null, ptr); }
  75                 @Override long conv_to_c() { return 0; /*XXX*/ }
  76         }
  77         public final static class SendFundingCreated extends MessageSendEvent {
  78                 public byte[] node_id;
  79                 public FundingCreated msg;
  80                 private SendFundingCreated(Object _dummy, long ptr) { super(null, ptr); }
  81                 @Override long conv_to_c() { return 0; /*XXX*/ }
  82         }
  83         public final static class SendFundingSigned extends MessageSendEvent {
  84                 public byte[] node_id;
  85                 public FundingSigned msg;
  86                 private SendFundingSigned(Object _dummy, long ptr) { super(null, ptr); }
  87                 @Override long conv_to_c() { return 0; /*XXX*/ }
  88         }
  89         public final static class SendFundingLocked extends MessageSendEvent {
  90                 public byte[] node_id;
  91                 public FundingLocked msg;
  92                 private SendFundingLocked(Object _dummy, long ptr) { super(null, ptr); }
  93                 @Override long conv_to_c() { return 0; /*XXX*/ }
  94         }
  95         public final static class SendAnnouncementSignatures extends MessageSendEvent {
  96                 public byte[] node_id;
  97                 public AnnouncementSignatures msg;
  98                 private SendAnnouncementSignatures(Object _dummy, long ptr) { super(null, ptr); }
  99                 @Override long conv_to_c() { return 0; /*XXX*/ }
 100         }
 101         public final static class UpdateHTLCs extends MessageSendEvent {
 102                 public byte[] node_id;
 103                 public CommitmentUpdate updates;
 104                 private UpdateHTLCs(Object _dummy, long ptr) { super(null, ptr); }
 105                 @Override long conv_to_c() { return 0; /*XXX*/ }
 106         }
 107         public final static class SendRevokeAndACK extends MessageSendEvent {
 108                 public byte[] node_id;
 109                 public RevokeAndACK msg;
 110                 private SendRevokeAndACK(Object _dummy, long ptr) { super(null, ptr); }
 111                 @Override long conv_to_c() { return 0; /*XXX*/ }
 112         }
 113         public final static class SendClosingSigned extends MessageSendEvent {
 114                 public byte[] node_id;
 115                 public ClosingSigned msg;
 116                 private SendClosingSigned(Object _dummy, long ptr) { super(null, ptr); }
 117                 @Override long conv_to_c() { return 0; /*XXX*/ }
 118         }
 119         public final static class SendShutdown extends MessageSendEvent {
 120                 public byte[] node_id;
 121                 public Shutdown msg;
 122                 private SendShutdown(Object _dummy, long ptr) { super(null, ptr); }
 123                 @Override long conv_to_c() { return 0; /*XXX*/ }
 124         }
 125         public final static class SendChannelReestablish extends MessageSendEvent {
 126                 public byte[] node_id;
 127                 public ChannelReestablish msg;
 128                 private SendChannelReestablish(Object _dummy, long ptr) { super(null, ptr); }
 129                 @Override long conv_to_c() { return 0; /*XXX*/ }
 130         }
 131         public final static class BroadcastChannelAnnouncement extends MessageSendEvent {
 132                 public ChannelAnnouncement msg;
 133                 public ChannelUpdate update_msg;
 134                 private BroadcastChannelAnnouncement(Object _dummy, long ptr) { super(null, ptr); }
 135                 @Override long conv_to_c() { return 0; /*XXX*/ }
 136         }
 137         public final static class BroadcastNodeAnnouncement extends MessageSendEvent {
 138                 public NodeAnnouncement msg;
 139                 private BroadcastNodeAnnouncement(Object _dummy, long ptr) { super(null, ptr); }
 140                 @Override long conv_to_c() { return 0; /*XXX*/ }
 141         }
 142         public final static class BroadcastChannelUpdate extends MessageSendEvent {
 143                 public ChannelUpdate msg;
 144                 private BroadcastChannelUpdate(Object _dummy, long ptr) { super(null, ptr); }
 145                 @Override long conv_to_c() { return 0; /*XXX*/ }
 146         }
 147         public final static class HandleError extends MessageSendEvent {
 148                 public byte[] node_id;
 149                 public ErrorAction action;
 150                 private HandleError(Object _dummy, long ptr) { super(null, ptr); }
 151                 @Override long conv_to_c() { return 0; /*XXX*/ }
 152         }
 153         public final static class PaymentFailureNetworkUpdate extends MessageSendEvent {
 154                 public HTLCFailChannelUpdate update;
 155                 private PaymentFailureNetworkUpdate(Object _dummy, long ptr) { super(null, ptr); }
 156                 @Override long conv_to_c() { return 0; /*XXX*/ }
 157         }
 158 }