7 Event(const Event&) = delete;
8 Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
9 Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
10 operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
11 ~Event() { Event_free(self); }
12 Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
13 LDKEvent* operator &() { return &self; }
14 LDKEvent* operator ->() { return &self; }
15 const LDKEvent* operator &() const { return &self; }
16 const LDKEvent* operator ->() const { return &self; }
18 class MessageSendEvent {
20 LDKMessageSendEvent self;
22 MessageSendEvent(const MessageSendEvent&) = delete;
23 MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
24 MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
25 operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
26 ~MessageSendEvent() { MessageSendEvent_free(self); }
27 MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
28 LDKMessageSendEvent* operator &() { return &self; }
29 LDKMessageSendEvent* operator ->() { return &self; }
30 const LDKMessageSendEvent* operator &() const { return &self; }
31 const LDKMessageSendEvent* operator ->() const { return &self; }
33 class MessageSendEventsProvider {
35 LDKMessageSendEventsProvider self;
37 MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
38 MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
39 MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
40 operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
41 ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
42 MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
43 LDKMessageSendEventsProvider* operator &() { return &self; }
44 LDKMessageSendEventsProvider* operator ->() { return &self; }
45 const LDKMessageSendEventsProvider* operator &() const { return &self; }
46 const LDKMessageSendEventsProvider* operator ->() const { return &self; }
48 class EventsProvider {
50 LDKEventsProvider self;
52 EventsProvider(const EventsProvider&) = delete;
53 EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
54 EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
55 operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
56 ~EventsProvider() { EventsProvider_free(self); }
57 EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
58 LDKEventsProvider* operator &() { return &self; }
59 LDKEventsProvider* operator ->() { return &self; }
60 const LDKEventsProvider* operator &() const { return &self; }
61 const LDKEventsProvider* operator ->() const { return &self; }
67 APIError(const APIError&) = delete;
68 APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
69 APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
70 operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
71 ~APIError() { APIError_free(self); }
72 APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
73 LDKAPIError* operator &() { return &self; }
74 LDKAPIError* operator ->() { return &self; }
75 const LDKAPIError* operator &() const { return &self; }
76 const LDKAPIError* operator ->() const { return &self; }
82 Level(const Level&) = delete;
83 Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
84 Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
85 operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
86 Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
87 LDKLevel* operator &() { return &self; }
88 LDKLevel* operator ->() { return &self; }
89 const LDKLevel* operator &() const { return &self; }
90 const LDKLevel* operator ->() const { return &self; }
96 Logger(const Logger&) = delete;
97 Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
98 Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
99 operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
100 ~Logger() { Logger_free(self); }
101 Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
102 LDKLogger* operator &() { return &self; }
103 LDKLogger* operator ->() { return &self; }
104 const LDKLogger* operator &() const { return &self; }
105 const LDKLogger* operator ->() const { return &self; }
107 class ChannelHandshakeConfig {
109 LDKChannelHandshakeConfig self;
111 ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
112 ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
113 ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
114 operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
115 ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
116 ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
117 LDKChannelHandshakeConfig* operator &() { return &self; }
118 LDKChannelHandshakeConfig* operator ->() { return &self; }
119 const LDKChannelHandshakeConfig* operator &() const { return &self; }
120 const LDKChannelHandshakeConfig* operator ->() const { return &self; }
122 class ChannelHandshakeLimits {
124 LDKChannelHandshakeLimits self;
126 ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
127 ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
128 ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
129 operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
130 ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
131 ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
132 LDKChannelHandshakeLimits* operator &() { return &self; }
133 LDKChannelHandshakeLimits* operator ->() { return &self; }
134 const LDKChannelHandshakeLimits* operator &() const { return &self; }
135 const LDKChannelHandshakeLimits* operator ->() const { return &self; }
137 class ChannelConfig {
139 LDKChannelConfig self;
141 ChannelConfig(const ChannelConfig&) = delete;
142 ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
143 ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
144 operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
145 ~ChannelConfig() { ChannelConfig_free(self); }
146 ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
147 LDKChannelConfig* operator &() { return &self; }
148 LDKChannelConfig* operator ->() { return &self; }
149 const LDKChannelConfig* operator &() const { return &self; }
150 const LDKChannelConfig* operator ->() const { return &self; }
156 UserConfig(const UserConfig&) = delete;
157 UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
158 UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
159 operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
160 ~UserConfig() { UserConfig_free(self); }
161 UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
162 LDKUserConfig* operator &() { return &self; }
163 LDKUserConfig* operator ->() { return &self; }
164 const LDKUserConfig* operator &() const { return &self; }
165 const LDKUserConfig* operator ->() const { return &self; }
167 class BroadcasterInterface {
169 LDKBroadcasterInterface self;
171 BroadcasterInterface(const BroadcasterInterface&) = delete;
172 BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
173 BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
174 operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
175 ~BroadcasterInterface() { BroadcasterInterface_free(self); }
176 BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
177 LDKBroadcasterInterface* operator &() { return &self; }
178 LDKBroadcasterInterface* operator ->() { return &self; }
179 const LDKBroadcasterInterface* operator &() const { return &self; }
180 const LDKBroadcasterInterface* operator ->() const { return &self; }
182 class ConfirmationTarget {
184 LDKConfirmationTarget self;
186 ConfirmationTarget(const ConfirmationTarget&) = delete;
187 ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
188 ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
189 operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
190 ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
191 LDKConfirmationTarget* operator &() { return &self; }
192 LDKConfirmationTarget* operator ->() { return &self; }
193 const LDKConfirmationTarget* operator &() const { return &self; }
194 const LDKConfirmationTarget* operator ->() const { return &self; }
198 LDKFeeEstimator self;
200 FeeEstimator(const FeeEstimator&) = delete;
201 FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
202 FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
203 operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
204 ~FeeEstimator() { FeeEstimator_free(self); }
205 FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
206 LDKFeeEstimator* operator &() { return &self; }
207 LDKFeeEstimator* operator ->() { return &self; }
208 const LDKFeeEstimator* operator &() const { return &self; }
209 const LDKFeeEstimator* operator ->() const { return &self; }
213 LDKChainMonitor self;
215 ChainMonitor(const ChainMonitor&) = delete;
216 ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
217 ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
218 operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
219 ~ChainMonitor() { ChainMonitor_free(self); }
220 ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
221 LDKChainMonitor* operator &() { return &self; }
222 LDKChainMonitor* operator ->() { return &self; }
223 const LDKChainMonitor* operator &() const { return &self; }
224 const LDKChainMonitor* operator ->() const { return &self; }
226 class ChannelMonitorUpdate {
228 LDKChannelMonitorUpdate self;
230 ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
231 ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
232 ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
233 operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
234 ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
235 ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
236 LDKChannelMonitorUpdate* operator &() { return &self; }
237 LDKChannelMonitorUpdate* operator ->() { return &self; }
238 const LDKChannelMonitorUpdate* operator &() const { return &self; }
239 const LDKChannelMonitorUpdate* operator ->() const { return &self; }
241 class ChannelMonitorUpdateErr {
243 LDKChannelMonitorUpdateErr self;
245 ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
246 ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
247 ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
248 operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
249 ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
250 LDKChannelMonitorUpdateErr* operator &() { return &self; }
251 LDKChannelMonitorUpdateErr* operator ->() { return &self; }
252 const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
253 const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
255 class MonitorUpdateError {
257 LDKMonitorUpdateError self;
259 MonitorUpdateError(const MonitorUpdateError&) = delete;
260 MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
261 MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
262 operator LDKMonitorUpdateError() && { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
263 ~MonitorUpdateError() { MonitorUpdateError_free(self); }
264 MonitorUpdateError& operator=(MonitorUpdateError&& o) { MonitorUpdateError_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateError)); return *this; }
265 LDKMonitorUpdateError* operator &() { return &self; }
266 LDKMonitorUpdateError* operator ->() { return &self; }
267 const LDKMonitorUpdateError* operator &() const { return &self; }
268 const LDKMonitorUpdateError* operator ->() const { return &self; }
272 LDKMonitorEvent self;
274 MonitorEvent(const MonitorEvent&) = delete;
275 MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
276 MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
277 operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
278 ~MonitorEvent() { MonitorEvent_free(self); }
279 MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
280 LDKMonitorEvent* operator &() { return &self; }
281 LDKMonitorEvent* operator ->() { return &self; }
282 const LDKMonitorEvent* operator &() const { return &self; }
283 const LDKMonitorEvent* operator ->() const { return &self; }
289 HTLCUpdate(const HTLCUpdate&) = delete;
290 HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
291 HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
292 operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
293 ~HTLCUpdate() { HTLCUpdate_free(self); }
294 HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
295 LDKHTLCUpdate* operator &() { return &self; }
296 LDKHTLCUpdate* operator ->() { return &self; }
297 const LDKHTLCUpdate* operator &() const { return &self; }
298 const LDKHTLCUpdate* operator ->() const { return &self; }
300 class ChannelMonitor {
302 LDKChannelMonitor self;
304 ChannelMonitor(const ChannelMonitor&) = delete;
305 ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
306 ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
307 operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
308 ~ChannelMonitor() { ChannelMonitor_free(self); }
309 ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
310 LDKChannelMonitor* operator &() { return &self; }
311 LDKChannelMonitor* operator ->() { return &self; }
312 const LDKChannelMonitor* operator &() const { return &self; }
313 const LDKChannelMonitor* operator ->() const { return &self; }
319 Persist(const Persist&) = delete;
320 Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
321 Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
322 operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
323 ~Persist() { Persist_free(self); }
324 Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
325 LDKPersist* operator &() { return &self; }
326 LDKPersist* operator ->() { return &self; }
327 const LDKPersist* operator &() const { return &self; }
328 const LDKPersist* operator ->() const { return &self; }
334 OutPoint(const OutPoint&) = delete;
335 OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
336 OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
337 operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
338 ~OutPoint() { OutPoint_free(self); }
339 OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
340 LDKOutPoint* operator &() { return &self; }
341 LDKOutPoint* operator ->() { return &self; }
342 const LDKOutPoint* operator &() const { return &self; }
343 const LDKOutPoint* operator ->() const { return &self; }
345 class SpendableOutputDescriptor {
347 LDKSpendableOutputDescriptor self;
349 SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
350 SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
351 SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
352 operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
353 ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
354 SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
355 LDKSpendableOutputDescriptor* operator &() { return &self; }
356 LDKSpendableOutputDescriptor* operator ->() { return &self; }
357 const LDKSpendableOutputDescriptor* operator &() const { return &self; }
358 const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
364 ChannelKeys(const ChannelKeys&) = delete;
365 ChannelKeys(ChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelKeys)); }
366 ChannelKeys(LDKChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelKeys)); }
367 operator LDKChannelKeys() && { LDKChannelKeys res = self; memset(&self, 0, sizeof(LDKChannelKeys)); return res; }
368 ~ChannelKeys() { ChannelKeys_free(self); }
369 ChannelKeys& operator=(ChannelKeys&& o) { ChannelKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelKeys)); return *this; }
370 LDKChannelKeys* operator &() { return &self; }
371 LDKChannelKeys* operator ->() { return &self; }
372 const LDKChannelKeys* operator &() const { return &self; }
373 const LDKChannelKeys* operator ->() const { return &self; }
375 class KeysInterface {
377 LDKKeysInterface self;
379 KeysInterface(const KeysInterface&) = delete;
380 KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
381 KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
382 operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
383 ~KeysInterface() { KeysInterface_free(self); }
384 KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
385 LDKKeysInterface* operator &() { return &self; }
386 LDKKeysInterface* operator ->() { return &self; }
387 const LDKKeysInterface* operator &() const { return &self; }
388 const LDKKeysInterface* operator ->() const { return &self; }
390 class InMemoryChannelKeys {
392 LDKInMemoryChannelKeys self;
394 InMemoryChannelKeys(const InMemoryChannelKeys&) = delete;
395 InMemoryChannelKeys(InMemoryChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(InMemoryChannelKeys)); }
396 InMemoryChannelKeys(LDKInMemoryChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemoryChannelKeys)); }
397 operator LDKInMemoryChannelKeys() && { LDKInMemoryChannelKeys res = self; memset(&self, 0, sizeof(LDKInMemoryChannelKeys)); return res; }
398 ~InMemoryChannelKeys() { InMemoryChannelKeys_free(self); }
399 InMemoryChannelKeys& operator=(InMemoryChannelKeys&& o) { InMemoryChannelKeys_free(self); self = o.self; memset(&o, 0, sizeof(InMemoryChannelKeys)); return *this; }
400 LDKInMemoryChannelKeys* operator &() { return &self; }
401 LDKInMemoryChannelKeys* operator ->() { return &self; }
402 const LDKInMemoryChannelKeys* operator &() const { return &self; }
403 const LDKInMemoryChannelKeys* operator ->() const { return &self; }
409 KeysManager(const KeysManager&) = delete;
410 KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
411 KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
412 operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
413 ~KeysManager() { KeysManager_free(self); }
414 KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
415 LDKKeysManager* operator &() { return &self; }
416 LDKKeysManager* operator ->() { return &self; }
417 const LDKKeysManager* operator &() const { return &self; }
418 const LDKKeysManager* operator ->() const { return &self; }
424 AccessError(const AccessError&) = delete;
425 AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
426 AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
427 operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
428 AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
429 LDKAccessError* operator &() { return &self; }
430 LDKAccessError* operator ->() { return &self; }
431 const LDKAccessError* operator &() const { return &self; }
432 const LDKAccessError* operator ->() const { return &self; }
438 Access(const Access&) = delete;
439 Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
440 Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
441 operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
442 ~Access() { Access_free(self); }
443 Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
444 LDKAccess* operator &() { return &self; }
445 LDKAccess* operator ->() { return &self; }
446 const LDKAccess* operator &() const { return &self; }
447 const LDKAccess* operator ->() const { return &self; }
453 Watch(const Watch&) = delete;
454 Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
455 Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
456 operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
457 ~Watch() { Watch_free(self); }
458 Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
459 LDKWatch* operator &() { return &self; }
460 LDKWatch* operator ->() { return &self; }
461 const LDKWatch* operator &() const { return &self; }
462 const LDKWatch* operator ->() const { return &self; }
468 Filter(const Filter&) = delete;
469 Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
470 Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
471 operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
472 ~Filter() { Filter_free(self); }
473 Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
474 LDKFilter* operator &() { return &self; }
475 LDKFilter* operator ->() { return &self; }
476 const LDKFilter* operator &() const { return &self; }
477 const LDKFilter* operator ->() const { return &self; }
479 class ChannelManager {
481 LDKChannelManager self;
483 ChannelManager(const ChannelManager&) = delete;
484 ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
485 ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
486 operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
487 ~ChannelManager() { ChannelManager_free(self); }
488 ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
489 LDKChannelManager* operator &() { return &self; }
490 LDKChannelManager* operator ->() { return &self; }
491 const LDKChannelManager* operator &() const { return &self; }
492 const LDKChannelManager* operator ->() const { return &self; }
494 class ChannelDetails {
496 LDKChannelDetails self;
498 ChannelDetails(const ChannelDetails&) = delete;
499 ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
500 ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
501 operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
502 ~ChannelDetails() { ChannelDetails_free(self); }
503 ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
504 LDKChannelDetails* operator &() { return &self; }
505 LDKChannelDetails* operator ->() { return &self; }
506 const LDKChannelDetails* operator &() const { return &self; }
507 const LDKChannelDetails* operator ->() const { return &self; }
509 class PaymentSendFailure {
511 LDKPaymentSendFailure self;
513 PaymentSendFailure(const PaymentSendFailure&) = delete;
514 PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
515 PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
516 operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
517 ~PaymentSendFailure() { PaymentSendFailure_free(self); }
518 PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
519 LDKPaymentSendFailure* operator &() { return &self; }
520 LDKPaymentSendFailure* operator ->() { return &self; }
521 const LDKPaymentSendFailure* operator &() const { return &self; }
522 const LDKPaymentSendFailure* operator ->() const { return &self; }
524 class ChannelManagerReadArgs {
526 LDKChannelManagerReadArgs self;
528 ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
529 ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
530 ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
531 operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
532 ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
533 ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
534 LDKChannelManagerReadArgs* operator &() { return &self; }
535 LDKChannelManagerReadArgs* operator ->() { return &self; }
536 const LDKChannelManagerReadArgs* operator &() const { return &self; }
537 const LDKChannelManagerReadArgs* operator ->() const { return &self; }
543 DecodeError(const DecodeError&) = delete;
544 DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
545 DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
546 operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
547 ~DecodeError() { DecodeError_free(self); }
548 DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
549 LDKDecodeError* operator &() { return &self; }
550 LDKDecodeError* operator ->() { return &self; }
551 const LDKDecodeError* operator &() const { return &self; }
552 const LDKDecodeError* operator ->() const { return &self; }
558 Init(const Init&) = delete;
559 Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
560 Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
561 operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
562 ~Init() { Init_free(self); }
563 Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
564 LDKInit* operator &() { return &self; }
565 LDKInit* operator ->() { return &self; }
566 const LDKInit* operator &() const { return &self; }
567 const LDKInit* operator ->() const { return &self; }
571 LDKErrorMessage self;
573 ErrorMessage(const ErrorMessage&) = delete;
574 ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
575 ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
576 operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
577 ~ErrorMessage() { ErrorMessage_free(self); }
578 ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
579 LDKErrorMessage* operator &() { return &self; }
580 LDKErrorMessage* operator ->() { return &self; }
581 const LDKErrorMessage* operator &() const { return &self; }
582 const LDKErrorMessage* operator ->() const { return &self; }
588 Ping(const Ping&) = delete;
589 Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
590 Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
591 operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
592 ~Ping() { Ping_free(self); }
593 Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
594 LDKPing* operator &() { return &self; }
595 LDKPing* operator ->() { return &self; }
596 const LDKPing* operator &() const { return &self; }
597 const LDKPing* operator ->() const { return &self; }
603 Pong(const Pong&) = delete;
604 Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
605 Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
606 operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
607 ~Pong() { Pong_free(self); }
608 Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
609 LDKPong* operator &() { return &self; }
610 LDKPong* operator ->() { return &self; }
611 const LDKPong* operator &() const { return &self; }
612 const LDKPong* operator ->() const { return &self; }
618 OpenChannel(const OpenChannel&) = delete;
619 OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
620 OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
621 operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
622 ~OpenChannel() { OpenChannel_free(self); }
623 OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
624 LDKOpenChannel* operator &() { return &self; }
625 LDKOpenChannel* operator ->() { return &self; }
626 const LDKOpenChannel* operator &() const { return &self; }
627 const LDKOpenChannel* operator ->() const { return &self; }
629 class AcceptChannel {
631 LDKAcceptChannel self;
633 AcceptChannel(const AcceptChannel&) = delete;
634 AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
635 AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
636 operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
637 ~AcceptChannel() { AcceptChannel_free(self); }
638 AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
639 LDKAcceptChannel* operator &() { return &self; }
640 LDKAcceptChannel* operator ->() { return &self; }
641 const LDKAcceptChannel* operator &() const { return &self; }
642 const LDKAcceptChannel* operator ->() const { return &self; }
644 class FundingCreated {
646 LDKFundingCreated self;
648 FundingCreated(const FundingCreated&) = delete;
649 FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
650 FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
651 operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
652 ~FundingCreated() { FundingCreated_free(self); }
653 FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
654 LDKFundingCreated* operator &() { return &self; }
655 LDKFundingCreated* operator ->() { return &self; }
656 const LDKFundingCreated* operator &() const { return &self; }
657 const LDKFundingCreated* operator ->() const { return &self; }
659 class FundingSigned {
661 LDKFundingSigned self;
663 FundingSigned(const FundingSigned&) = delete;
664 FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
665 FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
666 operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
667 ~FundingSigned() { FundingSigned_free(self); }
668 FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
669 LDKFundingSigned* operator &() { return &self; }
670 LDKFundingSigned* operator ->() { return &self; }
671 const LDKFundingSigned* operator &() const { return &self; }
672 const LDKFundingSigned* operator ->() const { return &self; }
674 class FundingLocked {
676 LDKFundingLocked self;
678 FundingLocked(const FundingLocked&) = delete;
679 FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); }
680 FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); }
681 operator LDKFundingLocked() && { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; }
682 ~FundingLocked() { FundingLocked_free(self); }
683 FundingLocked& operator=(FundingLocked&& o) { FundingLocked_free(self); self = o.self; memset(&o, 0, sizeof(FundingLocked)); return *this; }
684 LDKFundingLocked* operator &() { return &self; }
685 LDKFundingLocked* operator ->() { return &self; }
686 const LDKFundingLocked* operator &() const { return &self; }
687 const LDKFundingLocked* operator ->() const { return &self; }
693 Shutdown(const Shutdown&) = delete;
694 Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
695 Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
696 operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
697 ~Shutdown() { Shutdown_free(self); }
698 Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
699 LDKShutdown* operator &() { return &self; }
700 LDKShutdown* operator ->() { return &self; }
701 const LDKShutdown* operator &() const { return &self; }
702 const LDKShutdown* operator ->() const { return &self; }
704 class ClosingSigned {
706 LDKClosingSigned self;
708 ClosingSigned(const ClosingSigned&) = delete;
709 ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
710 ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
711 operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
712 ~ClosingSigned() { ClosingSigned_free(self); }
713 ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
714 LDKClosingSigned* operator &() { return &self; }
715 LDKClosingSigned* operator ->() { return &self; }
716 const LDKClosingSigned* operator &() const { return &self; }
717 const LDKClosingSigned* operator ->() const { return &self; }
719 class UpdateAddHTLC {
721 LDKUpdateAddHTLC self;
723 UpdateAddHTLC(const UpdateAddHTLC&) = delete;
724 UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
725 UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
726 operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
727 ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
728 UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
729 LDKUpdateAddHTLC* operator &() { return &self; }
730 LDKUpdateAddHTLC* operator ->() { return &self; }
731 const LDKUpdateAddHTLC* operator &() const { return &self; }
732 const LDKUpdateAddHTLC* operator ->() const { return &self; }
734 class UpdateFulfillHTLC {
736 LDKUpdateFulfillHTLC self;
738 UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
739 UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
740 UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
741 operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
742 ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
743 UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
744 LDKUpdateFulfillHTLC* operator &() { return &self; }
745 LDKUpdateFulfillHTLC* operator ->() { return &self; }
746 const LDKUpdateFulfillHTLC* operator &() const { return &self; }
747 const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
749 class UpdateFailHTLC {
751 LDKUpdateFailHTLC self;
753 UpdateFailHTLC(const UpdateFailHTLC&) = delete;
754 UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
755 UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
756 operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
757 ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
758 UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
759 LDKUpdateFailHTLC* operator &() { return &self; }
760 LDKUpdateFailHTLC* operator ->() { return &self; }
761 const LDKUpdateFailHTLC* operator &() const { return &self; }
762 const LDKUpdateFailHTLC* operator ->() const { return &self; }
764 class UpdateFailMalformedHTLC {
766 LDKUpdateFailMalformedHTLC self;
768 UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
769 UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
770 UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
771 operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
772 ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
773 UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
774 LDKUpdateFailMalformedHTLC* operator &() { return &self; }
775 LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
776 const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
777 const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
779 class CommitmentSigned {
781 LDKCommitmentSigned self;
783 CommitmentSigned(const CommitmentSigned&) = delete;
784 CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
785 CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
786 operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
787 ~CommitmentSigned() { CommitmentSigned_free(self); }
788 CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
789 LDKCommitmentSigned* operator &() { return &self; }
790 LDKCommitmentSigned* operator ->() { return &self; }
791 const LDKCommitmentSigned* operator &() const { return &self; }
792 const LDKCommitmentSigned* operator ->() const { return &self; }
796 LDKRevokeAndACK self;
798 RevokeAndACK(const RevokeAndACK&) = delete;
799 RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
800 RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
801 operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
802 ~RevokeAndACK() { RevokeAndACK_free(self); }
803 RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
804 LDKRevokeAndACK* operator &() { return &self; }
805 LDKRevokeAndACK* operator ->() { return &self; }
806 const LDKRevokeAndACK* operator &() const { return &self; }
807 const LDKRevokeAndACK* operator ->() const { return &self; }
813 UpdateFee(const UpdateFee&) = delete;
814 UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
815 UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
816 operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
817 ~UpdateFee() { UpdateFee_free(self); }
818 UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
819 LDKUpdateFee* operator &() { return &self; }
820 LDKUpdateFee* operator ->() { return &self; }
821 const LDKUpdateFee* operator &() const { return &self; }
822 const LDKUpdateFee* operator ->() const { return &self; }
824 class DataLossProtect {
826 LDKDataLossProtect self;
828 DataLossProtect(const DataLossProtect&) = delete;
829 DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
830 DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
831 operator LDKDataLossProtect() && { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
832 ~DataLossProtect() { DataLossProtect_free(self); }
833 DataLossProtect& operator=(DataLossProtect&& o) { DataLossProtect_free(self); self = o.self; memset(&o, 0, sizeof(DataLossProtect)); return *this; }
834 LDKDataLossProtect* operator &() { return &self; }
835 LDKDataLossProtect* operator ->() { return &self; }
836 const LDKDataLossProtect* operator &() const { return &self; }
837 const LDKDataLossProtect* operator ->() const { return &self; }
839 class ChannelReestablish {
841 LDKChannelReestablish self;
843 ChannelReestablish(const ChannelReestablish&) = delete;
844 ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
845 ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
846 operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
847 ~ChannelReestablish() { ChannelReestablish_free(self); }
848 ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
849 LDKChannelReestablish* operator &() { return &self; }
850 LDKChannelReestablish* operator ->() { return &self; }
851 const LDKChannelReestablish* operator &() const { return &self; }
852 const LDKChannelReestablish* operator ->() const { return &self; }
854 class AnnouncementSignatures {
856 LDKAnnouncementSignatures self;
858 AnnouncementSignatures(const AnnouncementSignatures&) = delete;
859 AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
860 AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
861 operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
862 ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
863 AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
864 LDKAnnouncementSignatures* operator &() { return &self; }
865 LDKAnnouncementSignatures* operator ->() { return &self; }
866 const LDKAnnouncementSignatures* operator &() const { return &self; }
867 const LDKAnnouncementSignatures* operator ->() const { return &self; }
873 NetAddress(const NetAddress&) = delete;
874 NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
875 NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
876 operator LDKNetAddress() && { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
877 ~NetAddress() { NetAddress_free(self); }
878 NetAddress& operator=(NetAddress&& o) { NetAddress_free(self); self = o.self; memset(&o, 0, sizeof(NetAddress)); return *this; }
879 LDKNetAddress* operator &() { return &self; }
880 LDKNetAddress* operator ->() { return &self; }
881 const LDKNetAddress* operator &() const { return &self; }
882 const LDKNetAddress* operator ->() const { return &self; }
884 class UnsignedNodeAnnouncement {
886 LDKUnsignedNodeAnnouncement self;
888 UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
889 UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
890 UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
891 operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
892 ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
893 UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
894 LDKUnsignedNodeAnnouncement* operator &() { return &self; }
895 LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
896 const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
897 const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
899 class NodeAnnouncement {
901 LDKNodeAnnouncement self;
903 NodeAnnouncement(const NodeAnnouncement&) = delete;
904 NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
905 NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
906 operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
907 ~NodeAnnouncement() { NodeAnnouncement_free(self); }
908 NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
909 LDKNodeAnnouncement* operator &() { return &self; }
910 LDKNodeAnnouncement* operator ->() { return &self; }
911 const LDKNodeAnnouncement* operator &() const { return &self; }
912 const LDKNodeAnnouncement* operator ->() const { return &self; }
914 class UnsignedChannelAnnouncement {
916 LDKUnsignedChannelAnnouncement self;
918 UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
919 UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
920 UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
921 operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
922 ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
923 UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
924 LDKUnsignedChannelAnnouncement* operator &() { return &self; }
925 LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
926 const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
927 const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
929 class ChannelAnnouncement {
931 LDKChannelAnnouncement self;
933 ChannelAnnouncement(const ChannelAnnouncement&) = delete;
934 ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
935 ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
936 operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
937 ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
938 ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
939 LDKChannelAnnouncement* operator &() { return &self; }
940 LDKChannelAnnouncement* operator ->() { return &self; }
941 const LDKChannelAnnouncement* operator &() const { return &self; }
942 const LDKChannelAnnouncement* operator ->() const { return &self; }
944 class UnsignedChannelUpdate {
946 LDKUnsignedChannelUpdate self;
948 UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
949 UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
950 UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
951 operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
952 ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
953 UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
954 LDKUnsignedChannelUpdate* operator &() { return &self; }
955 LDKUnsignedChannelUpdate* operator ->() { return &self; }
956 const LDKUnsignedChannelUpdate* operator &() const { return &self; }
957 const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
959 class ChannelUpdate {
961 LDKChannelUpdate self;
963 ChannelUpdate(const ChannelUpdate&) = delete;
964 ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
965 ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
966 operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
967 ~ChannelUpdate() { ChannelUpdate_free(self); }
968 ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
969 LDKChannelUpdate* operator &() { return &self; }
970 LDKChannelUpdate* operator ->() { return &self; }
971 const LDKChannelUpdate* operator &() const { return &self; }
972 const LDKChannelUpdate* operator ->() const { return &self; }
974 class QueryChannelRange {
976 LDKQueryChannelRange self;
978 QueryChannelRange(const QueryChannelRange&) = delete;
979 QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
980 QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
981 operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
982 ~QueryChannelRange() { QueryChannelRange_free(self); }
983 QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
984 LDKQueryChannelRange* operator &() { return &self; }
985 LDKQueryChannelRange* operator ->() { return &self; }
986 const LDKQueryChannelRange* operator &() const { return &self; }
987 const LDKQueryChannelRange* operator ->() const { return &self; }
989 class ReplyChannelRange {
991 LDKReplyChannelRange self;
993 ReplyChannelRange(const ReplyChannelRange&) = delete;
994 ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
995 ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
996 operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
997 ~ReplyChannelRange() { ReplyChannelRange_free(self); }
998 ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
999 LDKReplyChannelRange* operator &() { return &self; }
1000 LDKReplyChannelRange* operator ->() { return &self; }
1001 const LDKReplyChannelRange* operator &() const { return &self; }
1002 const LDKReplyChannelRange* operator ->() const { return &self; }
1004 class QueryShortChannelIds {
1006 LDKQueryShortChannelIds self;
1008 QueryShortChannelIds(const QueryShortChannelIds&) = delete;
1009 QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
1010 QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
1011 operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
1012 ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
1013 QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
1014 LDKQueryShortChannelIds* operator &() { return &self; }
1015 LDKQueryShortChannelIds* operator ->() { return &self; }
1016 const LDKQueryShortChannelIds* operator &() const { return &self; }
1017 const LDKQueryShortChannelIds* operator ->() const { return &self; }
1019 class ReplyShortChannelIdsEnd {
1021 LDKReplyShortChannelIdsEnd self;
1023 ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
1024 ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
1025 ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
1026 operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
1027 ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
1028 ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
1029 LDKReplyShortChannelIdsEnd* operator &() { return &self; }
1030 LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
1031 const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
1032 const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
1034 class GossipTimestampFilter {
1036 LDKGossipTimestampFilter self;
1038 GossipTimestampFilter(const GossipTimestampFilter&) = delete;
1039 GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
1040 GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
1041 operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
1042 ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
1043 GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
1044 LDKGossipTimestampFilter* operator &() { return &self; }
1045 LDKGossipTimestampFilter* operator ->() { return &self; }
1046 const LDKGossipTimestampFilter* operator &() const { return &self; }
1047 const LDKGossipTimestampFilter* operator ->() const { return &self; }
1051 LDKErrorAction self;
1053 ErrorAction(const ErrorAction&) = delete;
1054 ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
1055 ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
1056 operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
1057 ~ErrorAction() { ErrorAction_free(self); }
1058 ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
1059 LDKErrorAction* operator &() { return &self; }
1060 LDKErrorAction* operator ->() { return &self; }
1061 const LDKErrorAction* operator &() const { return &self; }
1062 const LDKErrorAction* operator ->() const { return &self; }
1064 class LightningError {
1066 LDKLightningError self;
1068 LightningError(const LightningError&) = delete;
1069 LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
1070 LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
1071 operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
1072 ~LightningError() { LightningError_free(self); }
1073 LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
1074 LDKLightningError* operator &() { return &self; }
1075 LDKLightningError* operator ->() { return &self; }
1076 const LDKLightningError* operator &() const { return &self; }
1077 const LDKLightningError* operator ->() const { return &self; }
1079 class CommitmentUpdate {
1081 LDKCommitmentUpdate self;
1083 CommitmentUpdate(const CommitmentUpdate&) = delete;
1084 CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
1085 CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
1086 operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
1087 ~CommitmentUpdate() { CommitmentUpdate_free(self); }
1088 CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
1089 LDKCommitmentUpdate* operator &() { return &self; }
1090 LDKCommitmentUpdate* operator ->() { return &self; }
1091 const LDKCommitmentUpdate* operator &() const { return &self; }
1092 const LDKCommitmentUpdate* operator ->() const { return &self; }
1094 class HTLCFailChannelUpdate {
1096 LDKHTLCFailChannelUpdate self;
1098 HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete;
1099 HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); }
1100 HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); }
1101 operator LDKHTLCFailChannelUpdate() && { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; }
1102 ~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); }
1103 HTLCFailChannelUpdate& operator=(HTLCFailChannelUpdate&& o) { HTLCFailChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCFailChannelUpdate)); return *this; }
1104 LDKHTLCFailChannelUpdate* operator &() { return &self; }
1105 LDKHTLCFailChannelUpdate* operator ->() { return &self; }
1106 const LDKHTLCFailChannelUpdate* operator &() const { return &self; }
1107 const LDKHTLCFailChannelUpdate* operator ->() const { return &self; }
1109 class ChannelMessageHandler {
1111 LDKChannelMessageHandler self;
1113 ChannelMessageHandler(const ChannelMessageHandler&) = delete;
1114 ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
1115 ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
1116 operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
1117 ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
1118 ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
1119 LDKChannelMessageHandler* operator &() { return &self; }
1120 LDKChannelMessageHandler* operator ->() { return &self; }
1121 const LDKChannelMessageHandler* operator &() const { return &self; }
1122 const LDKChannelMessageHandler* operator ->() const { return &self; }
1124 class RoutingMessageHandler {
1126 LDKRoutingMessageHandler self;
1128 RoutingMessageHandler(const RoutingMessageHandler&) = delete;
1129 RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
1130 RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
1131 operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
1132 ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
1133 RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
1134 LDKRoutingMessageHandler* operator &() { return &self; }
1135 LDKRoutingMessageHandler* operator ->() { return &self; }
1136 const LDKRoutingMessageHandler* operator &() const { return &self; }
1137 const LDKRoutingMessageHandler* operator ->() const { return &self; }
1139 class MessageHandler {
1141 LDKMessageHandler self;
1143 MessageHandler(const MessageHandler&) = delete;
1144 MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
1145 MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
1146 operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
1147 ~MessageHandler() { MessageHandler_free(self); }
1148 MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
1149 LDKMessageHandler* operator &() { return &self; }
1150 LDKMessageHandler* operator ->() { return &self; }
1151 const LDKMessageHandler* operator &() const { return &self; }
1152 const LDKMessageHandler* operator ->() const { return &self; }
1154 class SocketDescriptor {
1156 LDKSocketDescriptor self;
1158 SocketDescriptor(const SocketDescriptor&) = delete;
1159 SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
1160 SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
1161 operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
1162 ~SocketDescriptor() { SocketDescriptor_free(self); }
1163 SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
1164 LDKSocketDescriptor* operator &() { return &self; }
1165 LDKSocketDescriptor* operator ->() { return &self; }
1166 const LDKSocketDescriptor* operator &() const { return &self; }
1167 const LDKSocketDescriptor* operator ->() const { return &self; }
1169 class PeerHandleError {
1171 LDKPeerHandleError self;
1173 PeerHandleError(const PeerHandleError&) = delete;
1174 PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
1175 PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
1176 operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
1177 ~PeerHandleError() { PeerHandleError_free(self); }
1178 PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
1179 LDKPeerHandleError* operator &() { return &self; }
1180 LDKPeerHandleError* operator ->() { return &self; }
1181 const LDKPeerHandleError* operator &() const { return &self; }
1182 const LDKPeerHandleError* operator ->() const { return &self; }
1186 LDKPeerManager self;
1188 PeerManager(const PeerManager&) = delete;
1189 PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
1190 PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
1191 operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
1192 ~PeerManager() { PeerManager_free(self); }
1193 PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
1194 LDKPeerManager* operator &() { return &self; }
1195 LDKPeerManager* operator ->() { return &self; }
1196 const LDKPeerManager* operator &() const { return &self; }
1197 const LDKPeerManager* operator ->() const { return &self; }
1199 class TxCreationKeys {
1201 LDKTxCreationKeys self;
1203 TxCreationKeys(const TxCreationKeys&) = delete;
1204 TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
1205 TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
1206 operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
1207 ~TxCreationKeys() { TxCreationKeys_free(self); }
1208 TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
1209 LDKTxCreationKeys* operator &() { return &self; }
1210 LDKTxCreationKeys* operator ->() { return &self; }
1211 const LDKTxCreationKeys* operator &() const { return &self; }
1212 const LDKTxCreationKeys* operator ->() const { return &self; }
1214 class ChannelPublicKeys {
1216 LDKChannelPublicKeys self;
1218 ChannelPublicKeys(const ChannelPublicKeys&) = delete;
1219 ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
1220 ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
1221 operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
1222 ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
1223 ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
1224 LDKChannelPublicKeys* operator &() { return &self; }
1225 LDKChannelPublicKeys* operator ->() { return &self; }
1226 const LDKChannelPublicKeys* operator &() const { return &self; }
1227 const LDKChannelPublicKeys* operator ->() const { return &self; }
1229 class HTLCOutputInCommitment {
1231 LDKHTLCOutputInCommitment self;
1233 HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
1234 HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
1235 HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
1236 operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
1237 ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
1238 HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
1239 LDKHTLCOutputInCommitment* operator &() { return &self; }
1240 LDKHTLCOutputInCommitment* operator ->() { return &self; }
1241 const LDKHTLCOutputInCommitment* operator &() const { return &self; }
1242 const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
1244 class ChannelTransactionParameters {
1246 LDKChannelTransactionParameters self;
1248 ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
1249 ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
1250 ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
1251 operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
1252 ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
1253 ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
1254 LDKChannelTransactionParameters* operator &() { return &self; }
1255 LDKChannelTransactionParameters* operator ->() { return &self; }
1256 const LDKChannelTransactionParameters* operator &() const { return &self; }
1257 const LDKChannelTransactionParameters* operator ->() const { return &self; }
1259 class CounterpartyChannelTransactionParameters {
1261 LDKCounterpartyChannelTransactionParameters self;
1263 CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
1264 CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
1265 CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
1266 operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
1267 ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
1268 CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
1269 LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
1270 LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
1271 const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
1272 const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
1274 class DirectedChannelTransactionParameters {
1276 LDKDirectedChannelTransactionParameters self;
1278 DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
1279 DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
1280 DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
1281 operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
1282 ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
1283 DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
1284 LDKDirectedChannelTransactionParameters* operator &() { return &self; }
1285 LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
1286 const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
1287 const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
1289 class HolderCommitmentTransaction {
1291 LDKHolderCommitmentTransaction self;
1293 HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
1294 HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
1295 HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
1296 operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
1297 ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
1298 HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
1299 LDKHolderCommitmentTransaction* operator &() { return &self; }
1300 LDKHolderCommitmentTransaction* operator ->() { return &self; }
1301 const LDKHolderCommitmentTransaction* operator &() const { return &self; }
1302 const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
1304 class BuiltCommitmentTransaction {
1306 LDKBuiltCommitmentTransaction self;
1308 BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
1309 BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
1310 BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
1311 operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
1312 ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
1313 BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
1314 LDKBuiltCommitmentTransaction* operator &() { return &self; }
1315 LDKBuiltCommitmentTransaction* operator ->() { return &self; }
1316 const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
1317 const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
1319 class CommitmentTransaction {
1321 LDKCommitmentTransaction self;
1323 CommitmentTransaction(const CommitmentTransaction&) = delete;
1324 CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
1325 CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
1326 operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
1327 ~CommitmentTransaction() { CommitmentTransaction_free(self); }
1328 CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
1329 LDKCommitmentTransaction* operator &() { return &self; }
1330 LDKCommitmentTransaction* operator ->() { return &self; }
1331 const LDKCommitmentTransaction* operator &() const { return &self; }
1332 const LDKCommitmentTransaction* operator ->() const { return &self; }
1334 class TrustedCommitmentTransaction {
1336 LDKTrustedCommitmentTransaction self;
1338 TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
1339 TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
1340 TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
1341 operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
1342 ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
1343 TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
1344 LDKTrustedCommitmentTransaction* operator &() { return &self; }
1345 LDKTrustedCommitmentTransaction* operator ->() { return &self; }
1346 const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
1347 const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
1349 class InitFeatures {
1351 LDKInitFeatures self;
1353 InitFeatures(const InitFeatures&) = delete;
1354 InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
1355 InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
1356 operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
1357 ~InitFeatures() { InitFeatures_free(self); }
1358 InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
1359 LDKInitFeatures* operator &() { return &self; }
1360 LDKInitFeatures* operator ->() { return &self; }
1361 const LDKInitFeatures* operator &() const { return &self; }
1362 const LDKInitFeatures* operator ->() const { return &self; }
1364 class NodeFeatures {
1366 LDKNodeFeatures self;
1368 NodeFeatures(const NodeFeatures&) = delete;
1369 NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
1370 NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
1371 operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
1372 ~NodeFeatures() { NodeFeatures_free(self); }
1373 NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
1374 LDKNodeFeatures* operator &() { return &self; }
1375 LDKNodeFeatures* operator ->() { return &self; }
1376 const LDKNodeFeatures* operator &() const { return &self; }
1377 const LDKNodeFeatures* operator ->() const { return &self; }
1379 class ChannelFeatures {
1381 LDKChannelFeatures self;
1383 ChannelFeatures(const ChannelFeatures&) = delete;
1384 ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
1385 ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
1386 operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
1387 ~ChannelFeatures() { ChannelFeatures_free(self); }
1388 ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
1389 LDKChannelFeatures* operator &() { return &self; }
1390 LDKChannelFeatures* operator ->() { return &self; }
1391 const LDKChannelFeatures* operator &() const { return &self; }
1392 const LDKChannelFeatures* operator ->() const { return &self; }
1398 RouteHop(const RouteHop&) = delete;
1399 RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1400 RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1401 operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1402 ~RouteHop() { RouteHop_free(self); }
1403 RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1404 LDKRouteHop* operator &() { return &self; }
1405 LDKRouteHop* operator ->() { return &self; }
1406 const LDKRouteHop* operator &() const { return &self; }
1407 const LDKRouteHop* operator ->() const { return &self; }
1413 Route(const Route&) = delete;
1414 Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1415 Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1416 operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1417 ~Route() { Route_free(self); }
1418 Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1419 LDKRoute* operator &() { return &self; }
1420 LDKRoute* operator ->() { return &self; }
1421 const LDKRoute* operator &() const { return &self; }
1422 const LDKRoute* operator ->() const { return &self; }
1428 RouteHint(const RouteHint&) = delete;
1429 RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1430 RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1431 operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1432 ~RouteHint() { RouteHint_free(self); }
1433 RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1434 LDKRouteHint* operator &() { return &self; }
1435 LDKRouteHint* operator ->() { return &self; }
1436 const LDKRouteHint* operator &() const { return &self; }
1437 const LDKRouteHint* operator ->() const { return &self; }
1439 class NetworkGraph {
1441 LDKNetworkGraph self;
1443 NetworkGraph(const NetworkGraph&) = delete;
1444 NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
1445 NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
1446 operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
1447 ~NetworkGraph() { NetworkGraph_free(self); }
1448 NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
1449 LDKNetworkGraph* operator &() { return &self; }
1450 LDKNetworkGraph* operator ->() { return &self; }
1451 const LDKNetworkGraph* operator &() const { return &self; }
1452 const LDKNetworkGraph* operator ->() const { return &self; }
1454 class LockedNetworkGraph {
1456 LDKLockedNetworkGraph self;
1458 LockedNetworkGraph(const LockedNetworkGraph&) = delete;
1459 LockedNetworkGraph(LockedNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(LockedNetworkGraph)); }
1460 LockedNetworkGraph(LDKLockedNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedNetworkGraph)); }
1461 operator LDKLockedNetworkGraph() && { LDKLockedNetworkGraph res = self; memset(&self, 0, sizeof(LDKLockedNetworkGraph)); return res; }
1462 ~LockedNetworkGraph() { LockedNetworkGraph_free(self); }
1463 LockedNetworkGraph& operator=(LockedNetworkGraph&& o) { LockedNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(LockedNetworkGraph)); return *this; }
1464 LDKLockedNetworkGraph* operator &() { return &self; }
1465 LDKLockedNetworkGraph* operator ->() { return &self; }
1466 const LDKLockedNetworkGraph* operator &() const { return &self; }
1467 const LDKLockedNetworkGraph* operator ->() const { return &self; }
1469 class NetGraphMsgHandler {
1471 LDKNetGraphMsgHandler self;
1473 NetGraphMsgHandler(const NetGraphMsgHandler&) = delete;
1474 NetGraphMsgHandler(NetGraphMsgHandler&& o) : self(o.self) { memset(&o, 0, sizeof(NetGraphMsgHandler)); }
1475 NetGraphMsgHandler(LDKNetGraphMsgHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetGraphMsgHandler)); }
1476 operator LDKNetGraphMsgHandler() && { LDKNetGraphMsgHandler res = self; memset(&self, 0, sizeof(LDKNetGraphMsgHandler)); return res; }
1477 ~NetGraphMsgHandler() { NetGraphMsgHandler_free(self); }
1478 NetGraphMsgHandler& operator=(NetGraphMsgHandler&& o) { NetGraphMsgHandler_free(self); self = o.self; memset(&o, 0, sizeof(NetGraphMsgHandler)); return *this; }
1479 LDKNetGraphMsgHandler* operator &() { return &self; }
1480 LDKNetGraphMsgHandler* operator ->() { return &self; }
1481 const LDKNetGraphMsgHandler* operator &() const { return &self; }
1482 const LDKNetGraphMsgHandler* operator ->() const { return &self; }
1484 class DirectionalChannelInfo {
1486 LDKDirectionalChannelInfo self;
1488 DirectionalChannelInfo(const DirectionalChannelInfo&) = delete;
1489 DirectionalChannelInfo(DirectionalChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectionalChannelInfo)); }
1490 DirectionalChannelInfo(LDKDirectionalChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectionalChannelInfo)); }
1491 operator LDKDirectionalChannelInfo() && { LDKDirectionalChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectionalChannelInfo)); return res; }
1492 ~DirectionalChannelInfo() { DirectionalChannelInfo_free(self); }
1493 DirectionalChannelInfo& operator=(DirectionalChannelInfo&& o) { DirectionalChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectionalChannelInfo)); return *this; }
1494 LDKDirectionalChannelInfo* operator &() { return &self; }
1495 LDKDirectionalChannelInfo* operator ->() { return &self; }
1496 const LDKDirectionalChannelInfo* operator &() const { return &self; }
1497 const LDKDirectionalChannelInfo* operator ->() const { return &self; }
1501 LDKChannelInfo self;
1503 ChannelInfo(const ChannelInfo&) = delete;
1504 ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
1505 ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
1506 operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
1507 ~ChannelInfo() { ChannelInfo_free(self); }
1508 ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
1509 LDKChannelInfo* operator &() { return &self; }
1510 LDKChannelInfo* operator ->() { return &self; }
1511 const LDKChannelInfo* operator &() const { return &self; }
1512 const LDKChannelInfo* operator ->() const { return &self; }
1516 LDKRoutingFees self;
1518 RoutingFees(const RoutingFees&) = delete;
1519 RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
1520 RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
1521 operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
1522 ~RoutingFees() { RoutingFees_free(self); }
1523 RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
1524 LDKRoutingFees* operator &() { return &self; }
1525 LDKRoutingFees* operator ->() { return &self; }
1526 const LDKRoutingFees* operator &() const { return &self; }
1527 const LDKRoutingFees* operator ->() const { return &self; }
1529 class NodeAnnouncementInfo {
1531 LDKNodeAnnouncementInfo self;
1533 NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
1534 NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
1535 NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
1536 operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
1537 ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
1538 NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
1539 LDKNodeAnnouncementInfo* operator &() { return &self; }
1540 LDKNodeAnnouncementInfo* operator ->() { return &self; }
1541 const LDKNodeAnnouncementInfo* operator &() const { return &self; }
1542 const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
1548 NodeInfo(const NodeInfo&) = delete;
1549 NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
1550 NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
1551 operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
1552 ~NodeInfo() { NodeInfo_free(self); }
1553 NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
1554 LDKNodeInfo* operator &() { return &self; }
1555 LDKNodeInfo* operator ->() { return &self; }
1556 const LDKNodeInfo* operator &() const { return &self; }
1557 const LDKNodeInfo* operator ->() const { return &self; }
1559 class CVec_SpendableOutputDescriptorZ {
1561 LDKCVec_SpendableOutputDescriptorZ self;
1563 CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
1564 CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
1565 CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
1566 operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
1567 ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
1568 CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
1569 LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
1570 LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
1571 const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
1572 const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
1574 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
1576 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
1578 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
1579 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
1580 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
1581 operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() && { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
1582 ~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
1583 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ& operator=(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return *this; }
1584 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
1585 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
1586 const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
1587 const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
1589 class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
1591 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
1593 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
1594 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
1595 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
1596 operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
1597 ~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
1598 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
1599 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
1600 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
1601 const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
1602 const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
1604 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1606 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
1608 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
1609 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
1610 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
1611 operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
1612 ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
1613 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
1614 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
1615 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
1616 const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
1617 const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
1619 class C2Tuple_BlockHashChannelManagerZ {
1621 LDKC2Tuple_BlockHashChannelManagerZ self;
1623 C2Tuple_BlockHashChannelManagerZ(const C2Tuple_BlockHashChannelManagerZ&) = delete;
1624 C2Tuple_BlockHashChannelManagerZ(C2Tuple_BlockHashChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); }
1625 C2Tuple_BlockHashChannelManagerZ(LDKC2Tuple_BlockHashChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); }
1626 operator LDKC2Tuple_BlockHashChannelManagerZ() && { LDKC2Tuple_BlockHashChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); return res; }
1627 ~C2Tuple_BlockHashChannelManagerZ() { C2Tuple_BlockHashChannelManagerZ_free(self); }
1628 C2Tuple_BlockHashChannelManagerZ& operator=(C2Tuple_BlockHashChannelManagerZ&& o) { C2Tuple_BlockHashChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); return *this; }
1629 LDKC2Tuple_BlockHashChannelManagerZ* operator &() { return &self; }
1630 LDKC2Tuple_BlockHashChannelManagerZ* operator ->() { return &self; }
1631 const LDKC2Tuple_BlockHashChannelManagerZ* operator &() const { return &self; }
1632 const LDKC2Tuple_BlockHashChannelManagerZ* operator ->() const { return &self; }
1634 class CVec_C2Tuple_u32TxOutZZ {
1636 LDKCVec_C2Tuple_u32TxOutZZ self;
1638 CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
1639 CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
1640 CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
1641 operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
1642 ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
1643 CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
1644 LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
1645 LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
1646 const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
1647 const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
1649 class CVec_SignatureZ {
1651 LDKCVec_SignatureZ self;
1653 CVec_SignatureZ(const CVec_SignatureZ&) = delete;
1654 CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
1655 CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
1656 operator LDKCVec_SignatureZ() && { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
1657 ~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
1658 CVec_SignatureZ& operator=(CVec_SignatureZ&& o) { CVec_SignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SignatureZ)); return *this; }
1659 LDKCVec_SignatureZ* operator &() { return &self; }
1660 LDKCVec_SignatureZ* operator ->() { return &self; }
1661 const LDKCVec_SignatureZ* operator &() const { return &self; }
1662 const LDKCVec_SignatureZ* operator ->() const { return &self; }
1664 class C2Tuple_SignatureCVec_SignatureZZ {
1666 LDKC2Tuple_SignatureCVec_SignatureZZ self;
1668 C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
1669 C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
1670 C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
1671 operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
1672 ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
1673 C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
1674 LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
1675 LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
1676 const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
1677 const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
1683 CVec_u64Z(const CVec_u64Z&) = delete;
1684 CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
1685 CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
1686 operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
1687 ~CVec_u64Z() { CVec_u64Z_free(self); }
1688 CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
1689 LDKCVec_u64Z* operator &() { return &self; }
1690 LDKCVec_u64Z* operator ->() { return &self; }
1691 const LDKCVec_u64Z* operator &() const { return &self; }
1692 const LDKCVec_u64Z* operator ->() const { return &self; }
1694 class CResult_GossipTimestampFilterDecodeErrorZ {
1696 LDKCResult_GossipTimestampFilterDecodeErrorZ self;
1698 CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
1699 CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
1700 CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
1701 operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
1702 ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
1703 CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
1704 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
1705 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
1706 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
1707 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
1709 class CResult_ChannelMonitorUpdateDecodeErrorZ {
1711 LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
1713 CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
1714 CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
1715 CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
1716 operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
1717 ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
1718 CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
1719 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
1720 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
1721 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
1722 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
1724 class CResult_ReplyChannelRangeDecodeErrorZ {
1726 LDKCResult_ReplyChannelRangeDecodeErrorZ self;
1728 CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
1729 CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
1730 CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
1731 operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
1732 ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
1733 CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
1734 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
1735 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
1736 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
1737 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
1739 class CResult_CVec_u8ZPeerHandleErrorZ {
1741 LDKCResult_CVec_u8ZPeerHandleErrorZ self;
1743 CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
1744 CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
1745 CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
1746 operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
1747 ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
1748 CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
1749 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
1750 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
1751 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
1752 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
1754 class CResult_TxOutAccessErrorZ {
1756 LDKCResult_TxOutAccessErrorZ self;
1758 CResult_TxOutAccessErrorZ(const CResult_TxOutAccessErrorZ&) = delete;
1759 CResult_TxOutAccessErrorZ(CResult_TxOutAccessErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); }
1760 CResult_TxOutAccessErrorZ(LDKCResult_TxOutAccessErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); }
1761 operator LDKCResult_TxOutAccessErrorZ() && { LDKCResult_TxOutAccessErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); return res; }
1762 ~CResult_TxOutAccessErrorZ() { CResult_TxOutAccessErrorZ_free(self); }
1763 CResult_TxOutAccessErrorZ& operator=(CResult_TxOutAccessErrorZ&& o) { CResult_TxOutAccessErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); return *this; }
1764 LDKCResult_TxOutAccessErrorZ* operator &() { return &self; }
1765 LDKCResult_TxOutAccessErrorZ* operator ->() { return &self; }
1766 const LDKCResult_TxOutAccessErrorZ* operator &() const { return &self; }
1767 const LDKCResult_TxOutAccessErrorZ* operator ->() const { return &self; }
1769 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
1771 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
1773 CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
1774 CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
1775 CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
1776 operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
1777 ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
1778 CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
1779 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
1780 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
1781 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
1782 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
1784 class CResult_TxCreationKeysSecpErrorZ {
1786 LDKCResult_TxCreationKeysSecpErrorZ self;
1788 CResult_TxCreationKeysSecpErrorZ(const CResult_TxCreationKeysSecpErrorZ&) = delete;
1789 CResult_TxCreationKeysSecpErrorZ(CResult_TxCreationKeysSecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysSecpErrorZ)); }
1790 CResult_TxCreationKeysSecpErrorZ(LDKCResult_TxCreationKeysSecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); }
1791 operator LDKCResult_TxCreationKeysSecpErrorZ() && { LDKCResult_TxCreationKeysSecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); return res; }
1792 ~CResult_TxCreationKeysSecpErrorZ() { CResult_TxCreationKeysSecpErrorZ_free(self); }
1793 CResult_TxCreationKeysSecpErrorZ& operator=(CResult_TxCreationKeysSecpErrorZ&& o) { CResult_TxCreationKeysSecpErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysSecpErrorZ)); return *this; }
1794 LDKCResult_TxCreationKeysSecpErrorZ* operator &() { return &self; }
1795 LDKCResult_TxCreationKeysSecpErrorZ* operator ->() { return &self; }
1796 const LDKCResult_TxCreationKeysSecpErrorZ* operator &() const { return &self; }
1797 const LDKCResult_TxCreationKeysSecpErrorZ* operator ->() const { return &self; }
1799 class CVec_RouteHintZ {
1801 LDKCVec_RouteHintZ self;
1803 CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
1804 CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
1805 CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
1806 operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
1807 ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
1808 CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
1809 LDKCVec_RouteHintZ* operator &() { return &self; }
1810 LDKCVec_RouteHintZ* operator ->() { return &self; }
1811 const LDKCVec_RouteHintZ* operator &() const { return &self; }
1812 const LDKCVec_RouteHintZ* operator ->() const { return &self; }
1814 class CResult_ChannelReestablishDecodeErrorZ {
1816 LDKCResult_ChannelReestablishDecodeErrorZ self;
1818 CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
1819 CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
1820 CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
1821 operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
1822 ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
1823 CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
1824 LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
1825 LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
1826 const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
1827 const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
1829 class CVec_CVec_RouteHopZZ {
1831 LDKCVec_CVec_RouteHopZZ self;
1833 CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
1834 CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
1835 CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
1836 operator LDKCVec_CVec_RouteHopZZ() && { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
1837 ~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
1838 CVec_CVec_RouteHopZZ& operator=(CVec_CVec_RouteHopZZ&& o) { CVec_CVec_RouteHopZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); return *this; }
1839 LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
1840 LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
1841 const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
1842 const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
1844 class CVec_UpdateAddHTLCZ {
1846 LDKCVec_UpdateAddHTLCZ self;
1848 CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
1849 CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
1850 CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
1851 operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
1852 ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
1853 CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
1854 LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
1855 LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
1856 const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
1857 const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
1859 class CResult_NoneLightningErrorZ {
1861 LDKCResult_NoneLightningErrorZ self;
1863 CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
1864 CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
1865 CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
1866 operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
1867 ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
1868 CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
1869 LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
1870 LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
1871 const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
1872 const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
1874 class CResult_NonePeerHandleErrorZ {
1876 LDKCResult_NonePeerHandleErrorZ self;
1878 CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
1879 CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
1880 CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
1881 operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
1882 ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
1883 CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
1884 LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
1885 LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
1886 const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
1887 const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
1889 class CResult_TrustedCommitmentTransactionNoneZ {
1891 LDKCResult_TrustedCommitmentTransactionNoneZ self;
1893 CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
1894 CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
1895 CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
1896 operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
1897 ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
1898 CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
1899 LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
1900 LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
1901 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
1902 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
1904 class CResult_CVec_SignatureZNoneZ {
1906 LDKCResult_CVec_SignatureZNoneZ self;
1908 CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
1909 CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
1910 CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
1911 operator LDKCResult_CVec_SignatureZNoneZ() && { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
1912 ~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
1913 CResult_CVec_SignatureZNoneZ& operator=(CResult_CVec_SignatureZNoneZ&& o) { CResult_CVec_SignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); return *this; }
1914 LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
1915 LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
1916 const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
1917 const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
1919 class CResult_PingDecodeErrorZ {
1921 LDKCResult_PingDecodeErrorZ self;
1923 CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
1924 CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
1925 CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
1926 operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
1927 ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
1928 CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
1929 LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
1930 LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
1931 const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
1932 const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
1934 class CResult_RoutingFeesDecodeErrorZ {
1936 LDKCResult_RoutingFeesDecodeErrorZ self;
1938 CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
1939 CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
1940 CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
1941 operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
1942 ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
1943 CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
1944 LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
1945 LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
1946 const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
1947 const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
1949 class CResult_ErrorMessageDecodeErrorZ {
1951 LDKCResult_ErrorMessageDecodeErrorZ self;
1953 CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
1954 CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
1955 CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
1956 operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
1957 ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
1958 CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
1959 LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
1960 LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
1961 const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
1962 const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
1964 class CResult_QueryShortChannelIdsDecodeErrorZ {
1966 LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
1968 CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
1969 CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
1970 CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
1971 operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
1972 ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
1973 CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
1974 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
1975 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
1976 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
1977 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
1979 class CResult_NoneAPIErrorZ {
1981 LDKCResult_NoneAPIErrorZ self;
1983 CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
1984 CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
1985 CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
1986 operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
1987 ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
1988 CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
1989 LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
1990 LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
1991 const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
1992 const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
1994 class CResult_QueryChannelRangeDecodeErrorZ {
1996 LDKCResult_QueryChannelRangeDecodeErrorZ self;
1998 CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
1999 CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
2000 CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
2001 operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
2002 ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
2003 CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
2004 LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
2005 LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
2006 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
2007 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
2009 class CVec_NetAddressZ {
2011 LDKCVec_NetAddressZ self;
2013 CVec_NetAddressZ(const CVec_NetAddressZ&) = delete;
2014 CVec_NetAddressZ(CVec_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NetAddressZ)); }
2015 CVec_NetAddressZ(LDKCVec_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NetAddressZ)); }
2016 operator LDKCVec_NetAddressZ() && { LDKCVec_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_NetAddressZ)); return res; }
2017 ~CVec_NetAddressZ() { CVec_NetAddressZ_free(self); }
2018 CVec_NetAddressZ& operator=(CVec_NetAddressZ&& o) { CVec_NetAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NetAddressZ)); return *this; }
2019 LDKCVec_NetAddressZ* operator &() { return &self; }
2020 LDKCVec_NetAddressZ* operator ->() { return &self; }
2021 const LDKCVec_NetAddressZ* operator &() const { return &self; }
2022 const LDKCVec_NetAddressZ* operator ->() const { return &self; }
2024 class C2Tuple_usizeTransactionZ {
2026 LDKC2Tuple_usizeTransactionZ self;
2028 C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
2029 C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
2030 C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
2031 operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
2032 ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
2033 C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
2034 LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
2035 LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
2036 const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
2037 const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
2039 class CVec_C2Tuple_usizeTransactionZZ {
2041 LDKCVec_C2Tuple_usizeTransactionZZ self;
2043 CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
2044 CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
2045 CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
2046 operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
2047 ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
2048 CVec_C2Tuple_usizeTransactionZZ& operator=(CVec_C2Tuple_usizeTransactionZZ&& o) { CVec_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); return *this; }
2049 LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
2050 LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
2051 const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
2052 const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
2054 class CVec_TransactionZ {
2056 LDKCVec_TransactionZ self;
2058 CVec_TransactionZ(const CVec_TransactionZ&) = delete;
2059 CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
2060 CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
2061 operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
2062 ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
2063 CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
2064 LDKCVec_TransactionZ* operator &() { return &self; }
2065 LDKCVec_TransactionZ* operator ->() { return &self; }
2066 const LDKCVec_TransactionZ* operator &() const { return &self; }
2067 const LDKCVec_TransactionZ* operator ->() const { return &self; }
2069 class CVec_ChannelMonitorZ {
2071 LDKCVec_ChannelMonitorZ self;
2073 CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
2074 CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
2075 CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
2076 operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
2077 ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
2078 CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
2079 LDKCVec_ChannelMonitorZ* operator &() { return &self; }
2080 LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
2081 const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
2082 const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
2084 class CVec_PublicKeyZ {
2086 LDKCVec_PublicKeyZ self;
2088 CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
2089 CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
2090 CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
2091 operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
2092 ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
2093 CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
2094 LDKCVec_PublicKeyZ* operator &() { return &self; }
2095 LDKCVec_PublicKeyZ* operator ->() { return &self; }
2096 const LDKCVec_PublicKeyZ* operator &() const { return &self; }
2097 const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
2099 class C2Tuple_u32TxOutZ {
2101 LDKC2Tuple_u32TxOutZ self;
2103 C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
2104 C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
2105 C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
2106 operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
2107 ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
2108 C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
2109 LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
2110 LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
2111 const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
2112 const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
2114 class CResult_boolLightningErrorZ {
2116 LDKCResult_boolLightningErrorZ self;
2118 CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
2119 CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
2120 CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
2121 operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
2122 ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
2123 CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
2124 LDKCResult_boolLightningErrorZ* operator &() { return &self; }
2125 LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
2126 const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
2127 const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
2129 class C2Tuple_BlockHashChannelMonitorZ {
2131 LDKC2Tuple_BlockHashChannelMonitorZ self;
2133 C2Tuple_BlockHashChannelMonitorZ(const C2Tuple_BlockHashChannelMonitorZ&) = delete;
2134 C2Tuple_BlockHashChannelMonitorZ(C2Tuple_BlockHashChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); }
2135 C2Tuple_BlockHashChannelMonitorZ(LDKC2Tuple_BlockHashChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); }
2136 operator LDKC2Tuple_BlockHashChannelMonitorZ() && { LDKC2Tuple_BlockHashChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); return res; }
2137 ~C2Tuple_BlockHashChannelMonitorZ() { C2Tuple_BlockHashChannelMonitorZ_free(self); }
2138 C2Tuple_BlockHashChannelMonitorZ& operator=(C2Tuple_BlockHashChannelMonitorZ&& o) { C2Tuple_BlockHashChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); return *this; }
2139 LDKC2Tuple_BlockHashChannelMonitorZ* operator &() { return &self; }
2140 LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() { return &self; }
2141 const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
2142 const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
2144 class CResult_SecretKeySecpErrorZ {
2146 LDKCResult_SecretKeySecpErrorZ self;
2148 CResult_SecretKeySecpErrorZ(const CResult_SecretKeySecpErrorZ&) = delete;
2149 CResult_SecretKeySecpErrorZ(CResult_SecretKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeySecpErrorZ)); }
2150 CResult_SecretKeySecpErrorZ(LDKCResult_SecretKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); }
2151 operator LDKCResult_SecretKeySecpErrorZ() && { LDKCResult_SecretKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); return res; }
2152 ~CResult_SecretKeySecpErrorZ() { CResult_SecretKeySecpErrorZ_free(self); }
2153 CResult_SecretKeySecpErrorZ& operator=(CResult_SecretKeySecpErrorZ&& o) { CResult_SecretKeySecpErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeySecpErrorZ)); return *this; }
2154 LDKCResult_SecretKeySecpErrorZ* operator &() { return &self; }
2155 LDKCResult_SecretKeySecpErrorZ* operator ->() { return &self; }
2156 const LDKCResult_SecretKeySecpErrorZ* operator &() const { return &self; }
2157 const LDKCResult_SecretKeySecpErrorZ* operator ->() const { return &self; }
2159 class CResult_NodeAnnouncementInfoDecodeErrorZ {
2161 LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
2163 CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
2164 CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
2165 CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
2166 operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
2167 ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
2168 CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
2169 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
2170 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
2171 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
2172 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
2174 class CResult_SpendableOutputDescriptorDecodeErrorZ {
2176 LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
2178 CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
2179 CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
2180 CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
2181 operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
2182 ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
2183 CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
2184 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
2185 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
2186 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
2187 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
2189 class CResult_NetAddressu8Z {
2191 LDKCResult_NetAddressu8Z self;
2193 CResult_NetAddressu8Z(const CResult_NetAddressu8Z&) = delete;
2194 CResult_NetAddressu8Z(CResult_NetAddressu8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetAddressu8Z)); }
2195 CResult_NetAddressu8Z(LDKCResult_NetAddressu8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetAddressu8Z)); }
2196 operator LDKCResult_NetAddressu8Z() && { LDKCResult_NetAddressu8Z res = self; memset(&self, 0, sizeof(LDKCResult_NetAddressu8Z)); return res; }
2197 ~CResult_NetAddressu8Z() { CResult_NetAddressu8Z_free(self); }
2198 CResult_NetAddressu8Z& operator=(CResult_NetAddressu8Z&& o) { CResult_NetAddressu8Z_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetAddressu8Z)); return *this; }
2199 LDKCResult_NetAddressu8Z* operator &() { return &self; }
2200 LDKCResult_NetAddressu8Z* operator ->() { return &self; }
2201 const LDKCResult_NetAddressu8Z* operator &() const { return &self; }
2202 const LDKCResult_NetAddressu8Z* operator ->() const { return &self; }
2204 class CVec_UpdateFailMalformedHTLCZ {
2206 LDKCVec_UpdateFailMalformedHTLCZ self;
2208 CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
2209 CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
2210 CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
2211 operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
2212 ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
2213 CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
2214 LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
2215 LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
2216 const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
2217 const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
2219 class CResult_UnsignedChannelUpdateDecodeErrorZ {
2221 LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
2223 CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
2224 CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
2225 CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
2226 operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
2227 ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
2228 CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
2229 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
2230 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
2231 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
2232 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
2236 LDKCVec_EventZ self;
2238 CVec_EventZ(const CVec_EventZ&) = delete;
2239 CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
2240 CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
2241 operator LDKCVec_EventZ() && { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
2242 ~CVec_EventZ() { CVec_EventZ_free(self); }
2243 CVec_EventZ& operator=(CVec_EventZ&& o) { CVec_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_EventZ)); return *this; }
2244 LDKCVec_EventZ* operator &() { return &self; }
2245 LDKCVec_EventZ* operator ->() { return &self; }
2246 const LDKCVec_EventZ* operator &() const { return &self; }
2247 const LDKCVec_EventZ* operator ->() const { return &self; }
2249 class CResult_NetworkGraphDecodeErrorZ {
2251 LDKCResult_NetworkGraphDecodeErrorZ self;
2253 CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
2254 CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
2255 CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
2256 operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
2257 ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
2258 CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
2259 LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
2260 LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
2261 const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
2262 const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
2264 class CVec_MonitorEventZ {
2266 LDKCVec_MonitorEventZ self;
2268 CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
2269 CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
2270 CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
2271 operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
2272 ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
2273 CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
2274 LDKCVec_MonitorEventZ* operator &() { return &self; }
2275 LDKCVec_MonitorEventZ* operator ->() { return &self; }
2276 const LDKCVec_MonitorEventZ* operator &() const { return &self; }
2277 const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
2279 class CResult_ChanKeySignerDecodeErrorZ {
2281 LDKCResult_ChanKeySignerDecodeErrorZ self;
2283 CResult_ChanKeySignerDecodeErrorZ(const CResult_ChanKeySignerDecodeErrorZ&) = delete;
2284 CResult_ChanKeySignerDecodeErrorZ(CResult_ChanKeySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChanKeySignerDecodeErrorZ)); }
2285 CResult_ChanKeySignerDecodeErrorZ(LDKCResult_ChanKeySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChanKeySignerDecodeErrorZ)); }
2286 operator LDKCResult_ChanKeySignerDecodeErrorZ() && { LDKCResult_ChanKeySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChanKeySignerDecodeErrorZ)); return res; }
2287 ~CResult_ChanKeySignerDecodeErrorZ() { CResult_ChanKeySignerDecodeErrorZ_free(self); }
2288 CResult_ChanKeySignerDecodeErrorZ& operator=(CResult_ChanKeySignerDecodeErrorZ&& o) { CResult_ChanKeySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChanKeySignerDecodeErrorZ)); return *this; }
2289 LDKCResult_ChanKeySignerDecodeErrorZ* operator &() { return &self; }
2290 LDKCResult_ChanKeySignerDecodeErrorZ* operator ->() { return &self; }
2291 const LDKCResult_ChanKeySignerDecodeErrorZ* operator &() const { return &self; }
2292 const LDKCResult_ChanKeySignerDecodeErrorZ* operator ->() const { return &self; }
2294 class CVec_RouteHopZ {
2296 LDKCVec_RouteHopZ self;
2298 CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
2299 CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
2300 CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
2301 operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
2302 ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
2303 CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
2304 LDKCVec_RouteHopZ* operator &() { return &self; }
2305 LDKCVec_RouteHopZ* operator ->() { return &self; }
2306 const LDKCVec_RouteHopZ* operator &() const { return &self; }
2307 const LDKCVec_RouteHopZ* operator ->() const { return &self; }
2309 class CResult_NoneChannelMonitorUpdateErrZ {
2311 LDKCResult_NoneChannelMonitorUpdateErrZ self;
2313 CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete;
2314 CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); }
2315 CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); }
2316 operator LDKCResult_NoneChannelMonitorUpdateErrZ() && { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; }
2317 ~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); }
2318 CResult_NoneChannelMonitorUpdateErrZ& operator=(CResult_NoneChannelMonitorUpdateErrZ&& o) { CResult_NoneChannelMonitorUpdateErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); return *this; }
2319 LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; }
2320 LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; }
2321 const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
2322 const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
2324 class CResult_NonePaymentSendFailureZ {
2326 LDKCResult_NonePaymentSendFailureZ self;
2328 CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
2329 CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
2330 CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
2331 operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
2332 ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
2333 CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
2334 LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
2335 LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
2336 const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
2337 const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
2339 class CResult_NodeInfoDecodeErrorZ {
2341 LDKCResult_NodeInfoDecodeErrorZ self;
2343 CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
2344 CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
2345 CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
2346 operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
2347 ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
2348 CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
2349 LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
2350 LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
2351 const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
2352 const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
2358 CVec_u8Z(const CVec_u8Z&) = delete;
2359 CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
2360 CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
2361 operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
2362 ~CVec_u8Z() { CVec_u8Z_free(self); }
2363 CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
2364 LDKCVec_u8Z* operator &() { return &self; }
2365 LDKCVec_u8Z* operator ->() { return &self; }
2366 const LDKCVec_u8Z* operator &() const { return &self; }
2367 const LDKCVec_u8Z* operator ->() const { return &self; }
2369 class CResult_PublicKeySecpErrorZ {
2371 LDKCResult_PublicKeySecpErrorZ self;
2373 CResult_PublicKeySecpErrorZ(const CResult_PublicKeySecpErrorZ&) = delete;
2374 CResult_PublicKeySecpErrorZ(CResult_PublicKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecpErrorZ)); }
2375 CResult_PublicKeySecpErrorZ(LDKCResult_PublicKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); }
2376 operator LDKCResult_PublicKeySecpErrorZ() && { LDKCResult_PublicKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); return res; }
2377 ~CResult_PublicKeySecpErrorZ() { CResult_PublicKeySecpErrorZ_free(self); }
2378 CResult_PublicKeySecpErrorZ& operator=(CResult_PublicKeySecpErrorZ&& o) { CResult_PublicKeySecpErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecpErrorZ)); return *this; }
2379 LDKCResult_PublicKeySecpErrorZ* operator &() { return &self; }
2380 LDKCResult_PublicKeySecpErrorZ* operator ->() { return &self; }
2381 const LDKCResult_PublicKeySecpErrorZ* operator &() const { return &self; }
2382 const LDKCResult_PublicKeySecpErrorZ* operator ->() const { return &self; }
2384 class CResult_RouteLightningErrorZ {
2386 LDKCResult_RouteLightningErrorZ self;
2388 CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
2389 CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
2390 CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
2391 operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
2392 ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
2393 CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
2394 LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
2395 LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
2396 const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
2397 const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
2399 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
2401 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
2403 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
2404 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
2405 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
2406 operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
2407 ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
2408 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
2409 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
2410 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
2411 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
2412 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
2414 class CResult_boolPeerHandleErrorZ {
2416 LDKCResult_boolPeerHandleErrorZ self;
2418 CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
2419 CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
2420 CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
2421 operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
2422 ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
2423 CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
2424 LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
2425 LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
2426 const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
2427 const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
2429 class CVec_UpdateFulfillHTLCZ {
2431 LDKCVec_UpdateFulfillHTLCZ self;
2433 CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
2434 CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
2435 CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
2436 operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
2437 ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
2438 CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
2439 LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
2440 LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
2441 const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
2442 const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
2444 class CResult_SignatureNoneZ {
2446 LDKCResult_SignatureNoneZ self;
2448 CResult_SignatureNoneZ(const CResult_SignatureNoneZ&) = delete;
2449 CResult_SignatureNoneZ(CResult_SignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignatureNoneZ)); }
2450 CResult_SignatureNoneZ(LDKCResult_SignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignatureNoneZ)); }
2451 operator LDKCResult_SignatureNoneZ() && { LDKCResult_SignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignatureNoneZ)); return res; }
2452 ~CResult_SignatureNoneZ() { CResult_SignatureNoneZ_free(self); }
2453 CResult_SignatureNoneZ& operator=(CResult_SignatureNoneZ&& o) { CResult_SignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignatureNoneZ)); return *this; }
2454 LDKCResult_SignatureNoneZ* operator &() { return &self; }
2455 LDKCResult_SignatureNoneZ* operator ->() { return &self; }
2456 const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
2457 const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
2459 class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
2461 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
2463 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&) = delete;
2464 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
2465 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
2466 operator LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return res; }
2467 ~C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); }
2468 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return *this; }
2469 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
2470 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
2471 const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
2472 const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
2474 class CResult_InitDecodeErrorZ {
2476 LDKCResult_InitDecodeErrorZ self;
2478 CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
2479 CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
2480 CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
2481 operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
2482 ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
2483 CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
2484 LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
2485 LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
2486 const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
2487 const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
2489 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
2491 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
2493 CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
2494 CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
2495 CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
2496 operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
2497 ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
2498 CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
2499 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
2500 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
2501 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
2502 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
2504 class CResult_CResult_NetAddressu8ZDecodeErrorZ {
2506 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ self;
2508 CResult_CResult_NetAddressu8ZDecodeErrorZ(const CResult_CResult_NetAddressu8ZDecodeErrorZ&) = delete;
2509 CResult_CResult_NetAddressu8ZDecodeErrorZ(CResult_CResult_NetAddressu8ZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CResult_NetAddressu8ZDecodeErrorZ)); }
2510 CResult_CResult_NetAddressu8ZDecodeErrorZ(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ)); }
2511 operator LDKCResult_CResult_NetAddressu8ZDecodeErrorZ() && { LDKCResult_CResult_NetAddressu8ZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ)); return res; }
2512 ~CResult_CResult_NetAddressu8ZDecodeErrorZ() { CResult_CResult_NetAddressu8ZDecodeErrorZ_free(self); }
2513 CResult_CResult_NetAddressu8ZDecodeErrorZ& operator=(CResult_CResult_NetAddressu8ZDecodeErrorZ&& o) { CResult_CResult_NetAddressu8ZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CResult_NetAddressu8ZDecodeErrorZ)); return *this; }
2514 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() { return &self; }
2515 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() { return &self; }
2516 const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator &() const { return &self; }
2517 const LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* operator ->() const { return &self; }
2519 class CVec_ChannelDetailsZ {
2521 LDKCVec_ChannelDetailsZ self;
2523 CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
2524 CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
2525 CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
2526 operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
2527 ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
2528 CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
2529 LDKCVec_ChannelDetailsZ* operator &() { return &self; }
2530 LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
2531 const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
2532 const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
2534 class CVec_MessageSendEventZ {
2536 LDKCVec_MessageSendEventZ self;
2538 CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
2539 CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
2540 CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
2541 operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
2542 ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
2543 CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
2544 LDKCVec_MessageSendEventZ* operator &() { return &self; }
2545 LDKCVec_MessageSendEventZ* operator ->() { return &self; }
2546 const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
2547 const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
2549 class CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
2551 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ self;
2553 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ&) = delete;
2554 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ)); }
2555 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ)); }
2556 operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ)); return res; }
2557 ~CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(self); }
2558 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ)); return *this; }
2559 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ* operator &() { return &self; }
2560 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ* operator ->() { return &self; }
2561 const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ* operator &() const { return &self; }
2562 const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ* operator ->() const { return &self; }
2564 class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
2566 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
2568 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
2569 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
2570 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
2571 operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
2572 ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
2573 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
2574 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
2575 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
2576 const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
2577 const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
2579 class C2Tuple_OutPointScriptZ {
2581 LDKC2Tuple_OutPointScriptZ self;
2583 C2Tuple_OutPointScriptZ(const C2Tuple_OutPointScriptZ&) = delete;
2584 C2Tuple_OutPointScriptZ(C2Tuple_OutPointScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); }
2585 C2Tuple_OutPointScriptZ(LDKC2Tuple_OutPointScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); }
2586 operator LDKC2Tuple_OutPointScriptZ() && { LDKC2Tuple_OutPointScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); return res; }
2587 ~C2Tuple_OutPointScriptZ() { C2Tuple_OutPointScriptZ_free(self); }
2588 C2Tuple_OutPointScriptZ& operator=(C2Tuple_OutPointScriptZ&& o) { C2Tuple_OutPointScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); return *this; }
2589 LDKC2Tuple_OutPointScriptZ* operator &() { return &self; }
2590 LDKC2Tuple_OutPointScriptZ* operator ->() { return &self; }
2591 const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
2592 const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
2594 class CResult_InMemoryChannelKeysDecodeErrorZ {
2596 LDKCResult_InMemoryChannelKeysDecodeErrorZ self;
2598 CResult_InMemoryChannelKeysDecodeErrorZ(const CResult_InMemoryChannelKeysDecodeErrorZ&) = delete;
2599 CResult_InMemoryChannelKeysDecodeErrorZ(CResult_InMemoryChannelKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemoryChannelKeysDecodeErrorZ)); }
2600 CResult_InMemoryChannelKeysDecodeErrorZ(LDKCResult_InMemoryChannelKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemoryChannelKeysDecodeErrorZ)); }
2601 operator LDKCResult_InMemoryChannelKeysDecodeErrorZ() && { LDKCResult_InMemoryChannelKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemoryChannelKeysDecodeErrorZ)); return res; }
2602 ~CResult_InMemoryChannelKeysDecodeErrorZ() { CResult_InMemoryChannelKeysDecodeErrorZ_free(self); }
2603 CResult_InMemoryChannelKeysDecodeErrorZ& operator=(CResult_InMemoryChannelKeysDecodeErrorZ&& o) { CResult_InMemoryChannelKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemoryChannelKeysDecodeErrorZ)); return *this; }
2604 LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator &() { return &self; }
2605 LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator ->() { return &self; }
2606 const LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator &() const { return &self; }
2607 const LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator ->() const { return &self; }
2609 class CVec_UpdateFailHTLCZ {
2611 LDKCVec_UpdateFailHTLCZ self;
2613 CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
2614 CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
2615 CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
2616 operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
2617 ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
2618 CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
2619 LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
2620 LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
2621 const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
2622 const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
2624 class CResult_RouteDecodeErrorZ {
2626 LDKCResult_RouteDecodeErrorZ self;
2628 CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
2629 CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
2630 CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
2631 operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
2632 ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
2633 CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
2634 LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
2635 LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
2636 const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
2637 const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
2639 class CVec_NodeAnnouncementZ {
2641 LDKCVec_NodeAnnouncementZ self;
2643 CVec_NodeAnnouncementZ(const CVec_NodeAnnouncementZ&) = delete;
2644 CVec_NodeAnnouncementZ(CVec_NodeAnnouncementZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); }
2645 CVec_NodeAnnouncementZ(LDKCVec_NodeAnnouncementZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); }
2646 operator LDKCVec_NodeAnnouncementZ() && { LDKCVec_NodeAnnouncementZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); return res; }
2647 ~CVec_NodeAnnouncementZ() { CVec_NodeAnnouncementZ_free(self); }
2648 CVec_NodeAnnouncementZ& operator=(CVec_NodeAnnouncementZ&& o) { CVec_NodeAnnouncementZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); return *this; }
2649 LDKCVec_NodeAnnouncementZ* operator &() { return &self; }
2650 LDKCVec_NodeAnnouncementZ* operator ->() { return &self; }
2651 const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; }
2652 const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; }
2654 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
2656 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
2658 CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
2659 CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
2660 CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
2661 operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
2662 ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
2663 CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
2664 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
2665 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
2666 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
2667 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
2669 class CResult_PongDecodeErrorZ {
2671 LDKCResult_PongDecodeErrorZ self;
2673 CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
2674 CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
2675 CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
2676 operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
2677 ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
2678 CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
2679 LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
2680 LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
2681 const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
2682 const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
2684 class CResult_NoneMonitorUpdateErrorZ {
2686 LDKCResult_NoneMonitorUpdateErrorZ self;
2688 CResult_NoneMonitorUpdateErrorZ(const CResult_NoneMonitorUpdateErrorZ&) = delete;
2689 CResult_NoneMonitorUpdateErrorZ(CResult_NoneMonitorUpdateErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); }
2690 CResult_NoneMonitorUpdateErrorZ(LDKCResult_NoneMonitorUpdateErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); }
2691 operator LDKCResult_NoneMonitorUpdateErrorZ() && { LDKCResult_NoneMonitorUpdateErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); return res; }
2692 ~CResult_NoneMonitorUpdateErrorZ() { CResult_NoneMonitorUpdateErrorZ_free(self); }
2693 CResult_NoneMonitorUpdateErrorZ& operator=(CResult_NoneMonitorUpdateErrorZ&& o) { CResult_NoneMonitorUpdateErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); return *this; }
2694 LDKCResult_NoneMonitorUpdateErrorZ* operator &() { return &self; }
2695 LDKCResult_NoneMonitorUpdateErrorZ* operator ->() { return &self; }
2696 const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
2697 const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }