- const LDKIgnoringMessageHandler* operator &() const { return &self; }
- const LDKIgnoringMessageHandler* operator ->() const { return &self; }
-};
-class ErroringMessageHandler {
-private:
- LDKErroringMessageHandler self;
-public:
- ErroringMessageHandler(const ErroringMessageHandler&) = delete;
- ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
- ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
- operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
- ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
- ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
- LDKErroringMessageHandler* operator &() { return &self; }
- LDKErroringMessageHandler* operator ->() { return &self; }
- const LDKErroringMessageHandler* operator &() const { return &self; }
- const LDKErroringMessageHandler* operator ->() const { return &self; }
-};
-class MessageHandler {
-private:
- LDKMessageHandler self;
-public:
- MessageHandler(const MessageHandler&) = delete;
- MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
- MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
- operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
- ~MessageHandler() { MessageHandler_free(self); }
- MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
- LDKMessageHandler* operator &() { return &self; }
- LDKMessageHandler* operator ->() { return &self; }
- const LDKMessageHandler* operator &() const { return &self; }
- const LDKMessageHandler* operator ->() const { return &self; }
-};
-class SocketDescriptor {
-private:
- LDKSocketDescriptor self;
-public:
- SocketDescriptor(const SocketDescriptor&) = delete;
- SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
- SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
- operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
- ~SocketDescriptor() { SocketDescriptor_free(self); }
- SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
- LDKSocketDescriptor* operator &() { return &self; }
- LDKSocketDescriptor* operator ->() { return &self; }
- const LDKSocketDescriptor* operator &() const { return &self; }
- const LDKSocketDescriptor* operator ->() const { return &self; }
- /**
- * Attempts to send some data from the given slice to the peer.
- *
- * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
- * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
- * called and further write attempts may occur until that time.
- *
- * If the returned size is smaller than `data.len()`, a
- * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
- * written. Additionally, until a `send_data` event completes fully, no further
- * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
- * prevent denial-of-service issues, you should not read or buffer any data from the socket
- * until then.
- *
- * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
- * (indicating that read events should be paused to prevent DoS in the send buffer),
- * `resume_read` may be set indicating that read events on this descriptor should resume. A
- * `resume_read` of false carries no meaning, and should not cause any action.
- */
- inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
- /**
- * Disconnect the socket pointed to by this SocketDescriptor.
- *
- * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
- * call (doing so is a noop).
- */
- inline void disconnect_socket();
- /** Checks if two objects are equal given this object's this_arg pointer and another object. */
- inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
- /**
- * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
- * This is used, for example, for inclusion of this object in a hash map.
- */
- inline uint64_t hash();
-};
-class PeerHandleError {
-private:
- LDKPeerHandleError self;
-public:
- PeerHandleError(const PeerHandleError&) = delete;
- PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
- PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
- operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
- ~PeerHandleError() { PeerHandleError_free(self); }
- PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
- LDKPeerHandleError* operator &() { return &self; }
- LDKPeerHandleError* operator ->() { return &self; }
- const LDKPeerHandleError* operator &() const { return &self; }
- const LDKPeerHandleError* operator ->() const { return &self; }
-};
-class PeerManager {
-private:
- LDKPeerManager self;
-public:
- PeerManager(const PeerManager&) = delete;
- PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
- PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
- operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
- ~PeerManager() { PeerManager_free(self); }
- PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
- LDKPeerManager* operator &() { return &self; }
- LDKPeerManager* operator ->() { return &self; }
- const LDKPeerManager* operator &() const { return &self; }
- const LDKPeerManager* operator ->() const { return &self; }
-};
-class NodeId {
-private:
- LDKNodeId self;
-public:
- NodeId(const NodeId&) = delete;
- NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
- NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
- operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
- ~NodeId() { NodeId_free(self); }
- NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
- LDKNodeId* operator &() { return &self; }
- LDKNodeId* operator ->() { return &self; }
- const LDKNodeId* operator &() const { return &self; }
- const LDKNodeId* operator ->() const { return &self; }
-};
-class NetworkGraph {
-private:
- LDKNetworkGraph self;
-public:
- NetworkGraph(const NetworkGraph&) = delete;
- NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
- NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
- operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
- ~NetworkGraph() { NetworkGraph_free(self); }
- NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
- LDKNetworkGraph* operator &() { return &self; }
- LDKNetworkGraph* operator ->() { return &self; }
- const LDKNetworkGraph* operator &() const { return &self; }
- const LDKNetworkGraph* operator ->() const { return &self; }
-};
-class ReadOnlyNetworkGraph {
-private:
- LDKReadOnlyNetworkGraph self;
-public:
- ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
- ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
- ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
- operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
- ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
- ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
- LDKReadOnlyNetworkGraph* operator &() { return &self; }
- LDKReadOnlyNetworkGraph* operator ->() { return &self; }
- const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
- const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
-};
-class NetworkUpdate {
-private:
- LDKNetworkUpdate self;
-public:
- NetworkUpdate(const NetworkUpdate&) = delete;
- NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
- NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
- operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
- ~NetworkUpdate() { NetworkUpdate_free(self); }
- NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
- LDKNetworkUpdate* operator &() { return &self; }
- LDKNetworkUpdate* operator ->() { return &self; }
- const LDKNetworkUpdate* operator &() const { return &self; }
- const LDKNetworkUpdate* operator ->() const { return &self; }
-};
-class NetGraphMsgHandler {
-private:
- LDKNetGraphMsgHandler self;
-public:
- NetGraphMsgHandler(const NetGraphMsgHandler&) = delete;
- NetGraphMsgHandler(NetGraphMsgHandler&& o) : self(o.self) { memset(&o, 0, sizeof(NetGraphMsgHandler)); }
- NetGraphMsgHandler(LDKNetGraphMsgHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetGraphMsgHandler)); }
- operator LDKNetGraphMsgHandler() && { LDKNetGraphMsgHandler res = self; memset(&self, 0, sizeof(LDKNetGraphMsgHandler)); return res; }
- ~NetGraphMsgHandler() { NetGraphMsgHandler_free(self); }
- NetGraphMsgHandler& operator=(NetGraphMsgHandler&& o) { NetGraphMsgHandler_free(self); self = o.self; memset(&o, 0, sizeof(NetGraphMsgHandler)); return *this; }
- LDKNetGraphMsgHandler* operator &() { return &self; }
- LDKNetGraphMsgHandler* operator ->() { return &self; }
- const LDKNetGraphMsgHandler* operator &() const { return &self; }
- const LDKNetGraphMsgHandler* operator ->() const { return &self; }
-};
-class ChannelUpdateInfo {
-private:
- LDKChannelUpdateInfo self;
-public:
- ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
- ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
- ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
- operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
- ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
- ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
- LDKChannelUpdateInfo* operator &() { return &self; }
- LDKChannelUpdateInfo* operator ->() { return &self; }
- const LDKChannelUpdateInfo* operator &() const { return &self; }
- const LDKChannelUpdateInfo* operator ->() const { return &self; }
-};
-class ChannelInfo {
-private:
- LDKChannelInfo self;
-public:
- ChannelInfo(const ChannelInfo&) = delete;
- ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
- ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
- operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
- ~ChannelInfo() { ChannelInfo_free(self); }
- ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
- LDKChannelInfo* operator &() { return &self; }
- LDKChannelInfo* operator ->() { return &self; }
- const LDKChannelInfo* operator &() const { return &self; }
- const LDKChannelInfo* operator ->() const { return &self; }