+ if (ptr != 0) { bindings.EventsProvider_free(ptr); } super.finalize();
+ }
+
+ public static interface EventsProviderInterface {
+ /**
+ * Processes any events generated since the last call using the given event handler.
+ *
+ * Subsequent calls must only process new events. However, handlers must be capable of handling
+ * duplicate events across process restarts. This may occur if the provider was recovered from
+ * an old state (i.e., it hadn't been successfully persisted after processing pending events).
+ */
+ void process_pending_events(EventHandler handler);
+ }
+ private static class LDKEventsProviderHolder { EventsProvider held; }
+ public static EventsProvider new_impl(EventsProviderInterface arg) {
+ final LDKEventsProviderHolder impl_holder = new LDKEventsProviderHolder();
+ impl_holder.held = new EventsProvider(new bindings.LDKEventsProvider() {
+ @Override public void process_pending_events(long handler) {
+ EventHandler ret_hu_conv = new EventHandler(null, handler);
+ ret_hu_conv.ptrs_to.add(this);
+ arg.process_pending_events(ret_hu_conv);
+ }
+ });
+ return impl_holder.held;
+ }
+ /**
+ * Processes any events generated since the last call using the given event handler.
+ *
+ * Subsequent calls must only process new events. However, handlers must be capable of handling
+ * duplicate events across process restarts. This may occur if the provider was recovered from
+ * an old state (i.e., it hadn't been successfully persisted after processing pending events).
+ */
+ public void process_pending_events(EventHandler handler) {
+ bindings.EventsProvider_process_pending_events(this.ptr, handler == null ? 0 : handler.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(handler);
+ this.ptrs_to.add(handler);