Struct Handler 

pub struct Handler<T> { /* private fields */ }

Handler

Heap-allocated, reference-counted callback holder for callbacks the C client retains (fires later, possibly many times, from the conductor thread).

Handler<T> wraps Arc<UnsafeCell<T>>. The callback value lives on the heap and is freed only when the last clone drops. The raw clientd pointer handed to C is &T (via Handler::as_raw); C keeps firing it for as long as it holds the callback, so the Handler must outlive that — methods that register a retained callback (AeronContext::set_error_handler, the image lifecycle handlers on async_add_subscription, set_on_available_image, …) store a clone of the Handler inside the registering resource (as a dependency), so the value is guaranteed to outlive the C side’s use of it. No manual release() is needed.

Heap vs stack — when to reach for Handler vs a *_fn / *_once method

Callback kind	Where the closure lives	API
Retained (C stores it; fires later / repeatedly)	heap (Handler/Arc)	set_error_handler(Some(Handler::new(...))), async_add_subscription(.., Some(&h), ..), poll(Some(&h), limit)
Sync / call-only (C fires it during the call, then is done)	stack (borrowed FnMut, zero allocation)	poll_fn(|msg, hdr| ..., limit), the generated *_once variants

Prefer the stack form (poll_fn, *_once) on the hot path: it borrows the closure for the duration of the call only, so there is no Arc, no heap allocation, and the closure may borrow local state. Reach for Handler (heap) when the callback must survive past the registering call — image lifecycle handlers, error handlers, counters callbacks, anything the conductor invokes asynchronously.

The reference count is atomic (Arc), so a Handler may be moved to another thread; it is deliberately not Sync — callbacks fire from the conductor thread and must not be shared concurrently.

Example

use rusteron_code_gen::Handler;
let handler = Handler::new(your_value);
// the value is freed when the last clone of `handler` goes out of scope

Implementations

impl<T> Handler<T>

pub fn new(handler: T) -> Self

pub fn as_raw(&self) -> *mut c_void

pub unsafe fn get_mut(&self) -> &mut T

Get a mutable reference to the inner value.

Safety

Caller must ensure that no other references to the inner value are active.

impl<T: AeronFragmentHandlerCallback + 'static> Handler<T>

pub fn with_fragment_assembler( handler: T, ) -> Result<(Handler<AeronFragmentAssembler>, Handler<T>), AeronCError>

Wrap handler in a fragment assembler; both are reference-counted and freed automatically when the last clones drop (the assembler keeps the delegate alive).

pub fn leak_with_fragment_assembler( handler: T, ) -> Result<(Handler<AeronFragmentAssembler>, Handler<T>), AeronCError>

👎Deprecated: use Handler::with_fragment_assembler

impl<T: AeronControlledFragmentHandlerCallback + 'static> Handler<T>

pub fn with_controlled_fragment_assembler( handler: T, ) -> Result<(Handler<AeronControlledFragmentAssembler>, Handler<T>), AeronCError>

Wrap handler in a controlled fragment assembler; both are reference-counted and freed automatically when the last clones drop.

pub fn leak_with_controlled_fragment_assembler( handler: T, ) -> Result<(Handler<AeronControlledFragmentAssembler>, Handler<T>), AeronCError>

👎Deprecated: use Handler::with_controlled_fragment_assembler

Trait Implementations

impl<T: AeronAgentCloseFuncCallback> AeronAgentCloseFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_agent_on_close_func(&mut self)

impl<T: AeronAgentDoWorkFuncCallback> AeronAgentDoWorkFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_agent_do_work_func(&mut self) -> c_int

impl<T: AeronAgentStartFuncCallback> AeronAgentStartFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_agent_on_start_func(&mut self, role_name: &str)

impl<T: AeronAvailableCounterCallback> AeronAvailableCounterCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_available_counter( &mut self, counters_reader: AeronCountersReader, registration_id: i64, counter_id: i32, )

impl<T: AeronAvailableImageCallback> AeronAvailableImageCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_available_image( &mut self, subscription: AeronSubscription, image: AeronImage, )

impl<T: AeronBlockHandlerCallback> AeronBlockHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_block_handler( &mut self, buffer: &[u8], session_id: i32, term_id: i32, )

impl<T: AeronCloseClientCallback> AeronCloseClientCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_close_client(&mut self)

impl<T: AeronCongestionControlStrategyInitialWindowLengthFuncCallback> AeronCongestionControlStrategyInitialWindowLengthFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_congestion_control_strategy_initial_window_length_func( &mut self, ) -> i32

impl<T: AeronCongestionControlStrategyMaxWindowLengthFuncCallback> AeronCongestionControlStrategyMaxWindowLengthFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_congestion_control_strategy_max_window_length_func( &mut self, ) -> i32

impl<T: AeronCongestionControlStrategyRttmFuncCallback> AeronCongestionControlStrategyRttmFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_congestion_control_strategy_on_rttm_func( &mut self, now_ns: i64, rtt_ns: i64, source_address: SockaddrStorage, )

impl<T: AeronCongestionControlStrategyRttmSentFuncCallback> AeronCongestionControlStrategyRttmSentFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_congestion_control_strategy_on_rttm_sent_func( &mut self, now_ns: i64, )

impl<T: AeronCongestionControlStrategyShouldMeasureRttFuncCallback> AeronCongestionControlStrategyShouldMeasureRttFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_congestion_control_strategy_should_measure_rtt_func( &mut self, now_ns: i64, ) -> bool

impl<T: AeronControlledFragmentHandlerCallback> AeronControlledFragmentHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_controlled_fragment_handler( &mut self, buffer: &[u8], header: AeronHeader, ) -> aeron_controlled_fragment_handler_action_t

impl<T: AeronCountersReaderForeachCounterFuncCallback> AeronCountersReaderForeachCounterFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_counters_reader_foreach_counter_func( &mut self, value: i64, id: i32, type_id: i32, key: &[u8], label: &str, )

impl<T: AeronCountersReaderForeachMetadataFuncCallback> AeronCountersReaderForeachMetadataFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_counters_reader_foreach_metadata_func( &mut self, id: i32, type_id: i32, key: &[u8], label: &[u8], )

impl<T: AeronDriverTerminationHookFuncCallback> AeronDriverTerminationHookFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_driver_termination_hook_func(&mut self)

impl<T: AeronDriverTerminationValidatorFuncCallback> AeronDriverTerminationValidatorFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_driver_termination_validator_func( &mut self, buffer: &mut [u8], ) -> bool

impl<T: AeronDutyCycleTrackerMeasureAndUpdateFuncCallback> AeronDutyCycleTrackerMeasureAndUpdateFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_duty_cycle_tracker_measure_and_update_func( &mut self, now_ns: i64, )

impl<T: AeronDutyCycleTrackerUpdateFuncCallback> AeronDutyCycleTrackerUpdateFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_duty_cycle_tracker_update_func(&mut self, now_ns: i64)

impl<T: AeronEndOfLifeResourceFreeCallback> AeronEndOfLifeResourceFreeCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_end_of_life_resource_free(&mut self) -> bool

impl<T: AeronErrorHandlerCallback> AeronErrorHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_error_handler(&mut self, errcode: c_int, message: &str)

impl<T: AeronErrorLogReaderFuncCallback> AeronErrorLogReaderFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_error_log_reader_func( &mut self, observation_count: i32, first_observation_timestamp: i64, last_observation_timestamp: i64, error: &str, )

impl<T: AeronFlowControlStrategyErrorFuncCallback> AeronFlowControlStrategyErrorFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_on_error_func( &mut self, error: &[u8], recv_addr: SockaddrStorage, now_ns: i64, )

impl<T: AeronFlowControlStrategyIdleFuncCallback> AeronFlowControlStrategyIdleFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_on_idle_func( &mut self, now_ns: i64, snd_lmt: i64, snd_pos: i64, is_end_of_stream: bool, ) -> i64

impl<T: AeronFlowControlStrategyMaxRetransmissionLengthFuncCallback> AeronFlowControlStrategyMaxRetransmissionLengthFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_max_retransmission_length_func( &mut self, term_offset: usize, resend_length: usize, term_buffer_length: usize, mtu_length: usize, ) -> usize

impl<T: AeronFlowControlStrategySetupFuncCallback> AeronFlowControlStrategySetupFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_on_setup_func( &mut self, setup: &[u8], now_ns: i64, snd_lmt: i64, position_bits_to_shift: usize, snd_pos: i64, ) -> i64

impl<T: AeronFlowControlStrategySmFuncCallback> AeronFlowControlStrategySmFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_on_sm_func( &mut self, sm: &[u8], recv_addr: SockaddrStorage, snd_lmt: i64, initial_term_id: i32, position_bits_to_shift: usize, now_ns: i64, ) -> i64

impl<T: AeronFlowControlStrategyTriggerSendSetupFuncCallback> AeronFlowControlStrategyTriggerSendSetupFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_flow_control_strategy_on_trigger_send_setup_func( &mut self, sm: &[u8], recv_addr: SockaddrStorage, now_ns: i64, )

impl<T: AeronFprintfHandlerCallback> AeronFprintfHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_fprintf_handler( &mut self, arg1: &str, arg2: u64, arg4: &str, arg5: *mut c_char, ) -> c_int

impl<T: AeronFragmentHandlerCallback> AeronFragmentHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_fragment_handler(&mut self, buffer: &[u8], header: AeronHeader)

impl<T: AeronIdleStrategyFuncCallback> AeronIdleStrategyFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_idle_strategy_func(&mut self, work_count: c_int)

impl<T: AeronIfaddrFuncCallback> AeronIfaddrFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_ifaddr_func( &mut self, name: &str, addr: Sockaddr, netmask: Sockaddr, flags: c_uint, ) -> c_int

impl<T: AeronInt64CounterMapForEachFuncCallback> AeronInt64CounterMapForEachFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_counter_map_for_each_func(&mut self, key: i64, value: i64)

impl<T: AeronInt64CounterMapPredicateFuncCallback> AeronInt64CounterMapPredicateFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_counter_map_predicate_func( &mut self, key: i64, value: i64, ) -> bool

impl<T: AeronInt64ToPtrHashMapForEachFuncCallback> AeronInt64ToPtrHashMapForEachFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_to_ptr_hash_map_for_each_func( &mut self, key: i64, value: *mut c_void, )

impl<T: AeronInt64ToPtrHashMapPredicateFuncCallback> AeronInt64ToPtrHashMapPredicateFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_to_ptr_hash_map_predicate_func( &mut self, key: i64, value: *mut c_void, ) -> bool

impl<T: AeronInt64ToTaggedPtrHashMapForEachFuncCallback> AeronInt64ToTaggedPtrHashMapForEachFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_to_tagged_ptr_hash_map_for_each_func( &mut self, key: i64, tag: u32, value: *mut c_void, )

impl<T: AeronInt64ToTaggedPtrHashMapPredicateFuncCallback> AeronInt64ToTaggedPtrHashMapPredicateFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_int64_to_tagged_ptr_hash_map_predicate_func( &mut self, key: i64, tag: u32, value: *mut c_void, ) -> bool

impl<T: AeronLossGeneratorShouldDropFrameDetailedFuncCallback> AeronLossGeneratorShouldDropFrameDetailedFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_loss_generator_should_drop_frame_detailed_func( &mut self, address: *const sockaddr_storage, buffer: *const u8, stream_id: i32, session_id: i32, term_id: i32, term_offset: i32, length: i32, ) -> bool

impl<T: AeronLossGeneratorShouldDropFrameSimpleFuncCallback> AeronLossGeneratorShouldDropFrameSimpleFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_loss_generator_should_drop_frame_simple_func( &mut self, address: *const sockaddr_storage, buffer: &[u8], ) -> bool

impl<T: AeronLossReporterReadEntryFuncCallback> AeronLossReporterReadEntryFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_loss_reporter_read_entry_func( &mut self, observation_count: i64, total_bytes_lost: i64, first_observation_timestamp: i64, last_observation_timestamp: i64, session_id: i32, stream_id: i32, channel: &str, source: &str, )

impl<T: AeronNewPublicationCallback> AeronNewPublicationCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_new_publication( &mut self, channel: &str, stream_id: i32, session_id: i32, correlation_id: i64, )

impl<T: AeronNewSubscriptionCallback> AeronNewSubscriptionCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_new_subscription( &mut self, channel: &str, stream_id: i32, correlation_id: i64, )

impl<T: AeronNotificationCallback> AeronNotificationCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_notification(&mut self)

impl<T: AeronPortManagerFreeManagedPortFuncCallback> AeronPortManagerFreeManagedPortFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_port_manager_free_managed_port_func( &mut self, bind_addr: SockaddrStorage, )

impl<T: AeronPortManagerGetManagedPortFuncCallback> AeronPortManagerGetManagedPortFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_port_manager_get_managed_port_func( &mut self, bind_addr_out: SockaddrStorage, udp_channel: AeronUdpChannel, bind_addr: SockaddrStorage, ) -> c_int

impl<T: AeronPublicationErrorFrameHandlerCallback> AeronPublicationErrorFrameHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_publication_error_frame_handler( &mut self, error_frame: AeronPublicationErrorValues, )

impl<T: AeronQueueDrainFuncCallback> AeronQueueDrainFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_queue_drain_func(&mut self, item: *mut c_void)

impl<T: AeronRbControlledHandlerCallback> AeronRbControlledHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_rb_controlled_handler( &mut self, arg1: i32, arg2: *const c_void, arg3: usize, ) -> aeron_rb_read_action_t

impl<T: AeronRbHandlerCallback> AeronRbHandlerCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_rb_handler( &mut self, arg1: i32, arg2: *const c_void, arg3: usize, )

impl<T: AeronReceiveChannelLossSupplierFuncCallback> AeronReceiveChannelLossSupplierFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_receive_channel_loss_supplier_func( &mut self, endpoint: *mut aeron_receive_channel_endpoint_stct, )

impl<T: AeronReservedValueSupplierCallback> AeronReservedValueSupplierCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_reserved_value_supplier(&mut self, buffer: &mut [u8]) -> i64

impl<T: AeronRetransmitHandlerResendFuncCallback> AeronRetransmitHandlerResendFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_retransmit_handler_resend_func( &mut self, term_id: i32, term_offset: i32, length: usize, ) -> c_int

impl<T: AeronSendChannelLossSupplierFuncCallback> AeronSendChannelLossSupplierFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_send_channel_loss_supplier_func( &mut self, endpoint: *mut aeron_send_channel_endpoint_stct, )

impl<T: AeronStrToPtrHashMapForEachFuncCallback> AeronStrToPtrHashMapForEachFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_str_to_ptr_hash_map_for_each_func( &mut self, key: &str, value: *mut c_void, )

impl<T: AeronTermGapScannerGapDetectedFuncCallback> AeronTermGapScannerGapDetectedFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_term_gap_scanner_on_gap_detected_func( &mut self, term_id: i32, term_offset: i32, length: usize, )

impl<T: AeronUnavailableCounterCallback> AeronUnavailableCounterCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_unavailable_counter( &mut self, counters_reader: AeronCountersReader, registration_id: i64, counter_id: i32, )

impl<T: AeronUnavailableImageCallback> AeronUnavailableImageCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_on_unavailable_image( &mut self, subscription: AeronSubscription, image: AeronImage, )

impl<T: AeronUriHostnameResolverFuncCallback> AeronUriHostnameResolverFuncCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_uri_hostname_resolver_func( &mut self, host: &str, hints: Addrinfo, info: *mut *mut addrinfo, ) -> c_int

impl<T: AeronUriParseCallbackCallback> AeronUriParseCallbackCallback for Handler<T>

Pass an existing Handler clone anywhere a callback value is expected, e.g. to share one callback instance across several registrations.

fn handle_aeron_uri_parse_callback(&mut self, key: &str, value: &str) -> c_int

impl<T> Clone for Handler<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Deref for Handler<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Send> Send for Handler<T>