- LDKEvent self;
-public:
- Event(const Event&) = delete;
- Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
- Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
- operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
- ~Event() { Event_free(self); }
- Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
- LDKEvent* operator &() { return &self; }
- LDKEvent* operator ->() { return &self; }
- const LDKEvent* operator &() const { return &self; }
- const LDKEvent* operator ->() const { return &self; }
-};
-class MessageSendEvent {
-private:
- LDKMessageSendEvent self;
-public:
- MessageSendEvent(const MessageSendEvent&) = delete;
- MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
- MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
- operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
- ~MessageSendEvent() { MessageSendEvent_free(self); }
- MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
- LDKMessageSendEvent* operator &() { return &self; }
- LDKMessageSendEvent* operator ->() { return &self; }
- const LDKMessageSendEvent* operator &() const { return &self; }
- const LDKMessageSendEvent* operator ->() const { return &self; }
-};
-class MessageSendEventsProvider {
-private:
- LDKMessageSendEventsProvider self;
-public:
- MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
- MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
- MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
- operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
- ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
- MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
- LDKMessageSendEventsProvider* operator &() { return &self; }
- LDKMessageSendEventsProvider* operator ->() { return &self; }
- const LDKMessageSendEventsProvider* operator &() const { return &self; }
- const LDKMessageSendEventsProvider* operator ->() const { return &self; }
-};
-class EventsProvider {
-private:
- LDKEventsProvider self;
-public:
- EventsProvider(const EventsProvider&) = delete;
- EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
- EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
- operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
- ~EventsProvider() { EventsProvider_free(self); }
- EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
- LDKEventsProvider* operator &() { return &self; }
- LDKEventsProvider* operator ->() { return &self; }
- const LDKEventsProvider* operator &() const { return &self; }
- const LDKEventsProvider* operator ->() const { return &self; }
-};
-class AccessError {
-private:
- LDKAccessError self;
-public:
- AccessError(const AccessError&) = delete;
- AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
- AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
- operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
- AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
- LDKAccessError* operator &() { return &self; }
- LDKAccessError* operator ->() { return &self; }
- const LDKAccessError* operator &() const { return &self; }
- const LDKAccessError* operator ->() const { return &self; }
-};
-class Access {
-private:
- LDKAccess self;
-public:
- Access(const Access&) = delete;
- Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
- Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
- operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
- ~Access() { Access_free(self); }
- Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
- LDKAccess* operator &() { return &self; }
- LDKAccess* operator ->() { return &self; }
- const LDKAccess* operator &() const { return &self; }
- const LDKAccess* operator ->() const { return &self; }
-};
-class Listen {
-private:
- LDKListen self;
-public:
- Listen(const Listen&) = delete;
- Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
- Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
- operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
- ~Listen() { Listen_free(self); }
- Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
- LDKListen* operator &() { return &self; }
- LDKListen* operator ->() { return &self; }
- const LDKListen* operator &() const { return &self; }
- const LDKListen* operator ->() const { return &self; }
-};
-class Watch {
-private:
- LDKWatch self;
-public:
- Watch(const Watch&) = delete;
- Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
- Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
- operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
- ~Watch() { Watch_free(self); }
- Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
- LDKWatch* operator &() { return &self; }
- LDKWatch* operator ->() { return &self; }
- const LDKWatch* operator &() const { return &self; }
- const LDKWatch* operator ->() const { return &self; }
-};
-class Filter {
-private:
- LDKFilter self;
-public:
- Filter(const Filter&) = delete;
- Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
- Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
- operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
- ~Filter() { Filter_free(self); }
- Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
- LDKFilter* operator &() { return &self; }
- LDKFilter* operator ->() { return &self; }
- const LDKFilter* operator &() const { return &self; }
- const LDKFilter* operator ->() const { return &self; }
-};
-class WatchedOutput {
-private:
- LDKWatchedOutput self;
-public:
- WatchedOutput(const WatchedOutput&) = delete;
- WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
- WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
- operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
- ~WatchedOutput() { WatchedOutput_free(self); }
- WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
- LDKWatchedOutput* operator &() { return &self; }
- LDKWatchedOutput* operator ->() { return &self; }
- const LDKWatchedOutput* operator &() const { return &self; }
- const LDKWatchedOutput* operator ->() const { return &self; }
-};
-class BroadcasterInterface {
-private:
- LDKBroadcasterInterface self;
-public:
- BroadcasterInterface(const BroadcasterInterface&) = delete;
- BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
- BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
- operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
- ~BroadcasterInterface() { BroadcasterInterface_free(self); }
- BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
- LDKBroadcasterInterface* operator &() { return &self; }
- LDKBroadcasterInterface* operator ->() { return &self; }
- const LDKBroadcasterInterface* operator &() const { return &self; }
- const LDKBroadcasterInterface* operator ->() const { return &self; }
-};
-class ConfirmationTarget {
-private:
- LDKConfirmationTarget self;
-public:
- ConfirmationTarget(const ConfirmationTarget&) = delete;
- ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
- ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
- operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
- ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
- LDKConfirmationTarget* operator &() { return &self; }
- LDKConfirmationTarget* operator ->() { return &self; }
- const LDKConfirmationTarget* operator &() const { return &self; }
- const LDKConfirmationTarget* operator ->() const { return &self; }
-};
-class FeeEstimator {
-private:
- LDKFeeEstimator self;
-public:
- FeeEstimator(const FeeEstimator&) = delete;
- FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
- FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
- operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
- ~FeeEstimator() { FeeEstimator_free(self); }
- FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
- LDKFeeEstimator* operator &() { return &self; }
- LDKFeeEstimator* operator ->() { return &self; }
- const LDKFeeEstimator* operator &() const { return &self; }
- const LDKFeeEstimator* operator ->() const { return &self; }
-};
-class ChannelManager {
-private:
- LDKChannelManager self;
-public:
- ChannelManager(const ChannelManager&) = delete;
- ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
- ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
- operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
- ~ChannelManager() { ChannelManager_free(self); }
- ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
- LDKChannelManager* operator &() { return &self; }
- LDKChannelManager* operator ->() { return &self; }
- const LDKChannelManager* operator &() const { return &self; }
- const LDKChannelManager* operator ->() const { return &self; }
-};
-class ChainParameters {
-private:
- LDKChainParameters self;
-public:
- ChainParameters(const ChainParameters&) = delete;
- ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
- ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
- operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
- ~ChainParameters() { ChainParameters_free(self); }
- ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
- LDKChainParameters* operator &() { return &self; }
- LDKChainParameters* operator ->() { return &self; }
- const LDKChainParameters* operator &() const { return &self; }
- const LDKChainParameters* operator ->() const { return &self; }
-};
-class BestBlock {
-private:
- LDKBestBlock self;
-public:
- BestBlock(const BestBlock&) = delete;
- BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
- BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
- operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
- ~BestBlock() { BestBlock_free(self); }
- BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
- LDKBestBlock* operator &() { return &self; }
- LDKBestBlock* operator ->() { return &self; }
- const LDKBestBlock* operator &() const { return &self; }
- const LDKBestBlock* operator ->() const { return &self; }
-};
-class ChannelDetails {
-private:
- LDKChannelDetails self;
-public:
- ChannelDetails(const ChannelDetails&) = delete;
- ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
- ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
- operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
- ~ChannelDetails() { ChannelDetails_free(self); }
- ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
- LDKChannelDetails* operator &() { return &self; }
- LDKChannelDetails* operator ->() { return &self; }
- const LDKChannelDetails* operator &() const { return &self; }
- const LDKChannelDetails* operator ->() const { return &self; }
-};
-class PaymentSendFailure {
-private:
- LDKPaymentSendFailure self;
-public:
- PaymentSendFailure(const PaymentSendFailure&) = delete;
- PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
- PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
- operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
- ~PaymentSendFailure() { PaymentSendFailure_free(self); }
- PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
- LDKPaymentSendFailure* operator &() { return &self; }
- LDKPaymentSendFailure* operator ->() { return &self; }
- const LDKPaymentSendFailure* operator &() const { return &self; }
- const LDKPaymentSendFailure* operator ->() const { return &self; }
-};
-class ChannelManagerReadArgs {
-private:
- LDKChannelManagerReadArgs self;
-public:
- ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
- ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
- ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
- operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
- ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
- ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
- LDKChannelManagerReadArgs* operator &() { return &self; }
- LDKChannelManagerReadArgs* operator ->() { return &self; }
- const LDKChannelManagerReadArgs* operator &() const { return &self; }
- const LDKChannelManagerReadArgs* operator ->() const { return &self; }
-};
-class DelayedPaymentOutputDescriptor {
-private:
- LDKDelayedPaymentOutputDescriptor self;
-public:
- DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
- DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
- DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
- operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
- ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
- DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
- LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
- LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
- const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
- const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class StaticPaymentOutputDescriptor {
-private:
- LDKStaticPaymentOutputDescriptor self;
-public:
- StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
- StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
- StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
- operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
- ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
- StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
- LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
- LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
- const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
- const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class SpendableOutputDescriptor {
-private:
- LDKSpendableOutputDescriptor self;
-public:
- SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
- SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
- SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
- operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
- ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
- SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
- LDKSpendableOutputDescriptor* operator &() { return &self; }
- LDKSpendableOutputDescriptor* operator ->() { return &self; }
- const LDKSpendableOutputDescriptor* operator &() const { return &self; }
- const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
-};
-class BaseSign {
-private:
- LDKBaseSign self;
-public:
- BaseSign(const BaseSign&) = delete;
- BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
- BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
- operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
- ~BaseSign() { BaseSign_free(self); }
- BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
- LDKBaseSign* operator &() { return &self; }
- LDKBaseSign* operator ->() { return &self; }
- const LDKBaseSign* operator &() const { return &self; }
- const LDKBaseSign* operator ->() const { return &self; }
-};
-class Sign {
-private:
- LDKSign self;
-public:
- Sign(const Sign&) = delete;
- Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
- Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
- operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
- ~Sign() { Sign_free(self); }
- Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
- LDKSign* operator &() { return &self; }
- LDKSign* operator ->() { return &self; }
- const LDKSign* operator &() const { return &self; }
- const LDKSign* operator ->() const { return &self; }
-};
-class KeysInterface {
-private:
- LDKKeysInterface self;
-public:
- KeysInterface(const KeysInterface&) = delete;
- KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
- KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
- operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
- ~KeysInterface() { KeysInterface_free(self); }
- KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
- LDKKeysInterface* operator &() { return &self; }
- LDKKeysInterface* operator ->() { return &self; }
- const LDKKeysInterface* operator &() const { return &self; }
- const LDKKeysInterface* operator ->() const { return &self; }
-};
-class InMemorySigner {
-private:
- LDKInMemorySigner self;
-public:
- InMemorySigner(const InMemorySigner&) = delete;
- InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
- InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
- operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
- ~InMemorySigner() { InMemorySigner_free(self); }
- InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
- LDKInMemorySigner* operator &() { return &self; }
- LDKInMemorySigner* operator ->() { return &self; }
- const LDKInMemorySigner* operator &() const { return &self; }
- const LDKInMemorySigner* operator ->() const { return &self; }
-};
-class KeysManager {
-private:
- LDKKeysManager self;
-public:
- KeysManager(const KeysManager&) = delete;
- KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
- KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
- operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
- ~KeysManager() { KeysManager_free(self); }
- KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
- LDKKeysManager* operator &() { return &self; }
- LDKKeysManager* operator ->() { return &self; }
- const LDKKeysManager* operator &() const { return &self; }
- const LDKKeysManager* operator ->() const { return &self; }
-};
-class RouteHop {
-private:
- LDKRouteHop self;
-public:
- RouteHop(const RouteHop&) = delete;
- RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
- RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
- operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
- ~RouteHop() { RouteHop_free(self); }
- RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
- LDKRouteHop* operator &() { return &self; }
- LDKRouteHop* operator ->() { return &self; }
- const LDKRouteHop* operator &() const { return &self; }
- const LDKRouteHop* operator ->() const { return &self; }
-};
-class Route {
-private:
- LDKRoute self;
-public:
- Route(const Route&) = delete;
- Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
- Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
- operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
- ~Route() { Route_free(self); }
- Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
- LDKRoute* operator &() { return &self; }
- LDKRoute* operator ->() { return &self; }
- const LDKRoute* operator &() const { return &self; }
- const LDKRoute* operator ->() const { return &self; }
-};
-class RouteHint {
-private:
- LDKRouteHint self;
-public:
- RouteHint(const RouteHint&) = delete;
- RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
- RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
- operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
- ~RouteHint() { RouteHint_free(self); }
- RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
- LDKRouteHint* operator &() { return &self; }
- LDKRouteHint* operator ->() { return &self; }
- const LDKRouteHint* operator &() const { return &self; }
- const LDKRouteHint* operator ->() const { return &self; }
-};
-class DecodeError {
-private:
- LDKDecodeError self;
-public:
- DecodeError(const DecodeError&) = delete;
- DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
- DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
- operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
- ~DecodeError() { DecodeError_free(self); }
- DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
- LDKDecodeError* operator &() { return &self; }
- LDKDecodeError* operator ->() { return &self; }
- const LDKDecodeError* operator &() const { return &self; }
- const LDKDecodeError* operator ->() const { return &self; }
-};
-class Init {
-private:
- LDKInit self;
-public:
- Init(const Init&) = delete;
- Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
- Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
- operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
- ~Init() { Init_free(self); }
- Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
- LDKInit* operator &() { return &self; }
- LDKInit* operator ->() { return &self; }
- const LDKInit* operator &() const { return &self; }
- const LDKInit* operator ->() const { return &self; }
-};
-class ErrorMessage {
-private:
- LDKErrorMessage self;
-public:
- ErrorMessage(const ErrorMessage&) = delete;
- ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
- ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
- operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
- ~ErrorMessage() { ErrorMessage_free(self); }
- ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
- LDKErrorMessage* operator &() { return &self; }
- LDKErrorMessage* operator ->() { return &self; }
- const LDKErrorMessage* operator &() const { return &self; }
- const LDKErrorMessage* operator ->() const { return &self; }
-};
-class Ping {
-private:
- LDKPing self;
-public:
- Ping(const Ping&) = delete;
- Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
- Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
- operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
- ~Ping() { Ping_free(self); }
- Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
- LDKPing* operator &() { return &self; }
- LDKPing* operator ->() { return &self; }
- const LDKPing* operator &() const { return &self; }
- const LDKPing* operator ->() const { return &self; }
-};
-class Pong {
-private:
- LDKPong self;
-public:
- Pong(const Pong&) = delete;
- Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
- Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
- operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
- ~Pong() { Pong_free(self); }
- Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
- LDKPong* operator &() { return &self; }
- LDKPong* operator ->() { return &self; }
- const LDKPong* operator &() const { return &self; }
- const LDKPong* operator ->() const { return &self; }
-};
-class OpenChannel {
-private:
- LDKOpenChannel self;
-public:
- OpenChannel(const OpenChannel&) = delete;
- OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
- OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
- operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
- ~OpenChannel() { OpenChannel_free(self); }
- OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
- LDKOpenChannel* operator &() { return &self; }
- LDKOpenChannel* operator ->() { return &self; }
- const LDKOpenChannel* operator &() const { return &self; }
- const LDKOpenChannel* operator ->() const { return &self; }
-};
-class AcceptChannel {
-private:
- LDKAcceptChannel self;
-public:
- AcceptChannel(const AcceptChannel&) = delete;
- AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
- AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
- operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
- ~AcceptChannel() { AcceptChannel_free(self); }
- AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
- LDKAcceptChannel* operator &() { return &self; }
- LDKAcceptChannel* operator ->() { return &self; }
- const LDKAcceptChannel* operator &() const { return &self; }
- const LDKAcceptChannel* operator ->() const { return &self; }
-};
-class FundingCreated {
-private:
- LDKFundingCreated self;