Skip to main content

ControlHandler

dig_node_control_interface::traits

Trait ControlHandler 

Source 
pub trait ControlHandler: Sync {

Show 38 methods    // Required methods
    fn status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<StatusResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn config_get<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<ConfigResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn config_set_upstream<'life0, 'async_trait>(
        &'life0 self,
        params: SetUpstreamParams,
    ) -> Pin<Box<dyn Future<Output = Result<SetUpstreamResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn log_set_level<'life0, 'async_trait>(
        &'life0 self,
        params: SetLevelParams,
    ) -> Pin<Box<dyn Future<Output = Result<SetLevelResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn cache_get<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<CacheView, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn cache_set_cap<'life0, 'async_trait>(
        &'life0 self,
        params: SetCapParams,
    ) -> Pin<Box<dyn Future<Output = Result<SetCapResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn cache_clear<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<CacheClearResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn hosted_stores_list<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<HostedStoresListResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn hosted_stores_pin<'life0, 'async_trait>(
        &'life0 self,
        params: PinParams,
    ) -> Pin<Box<dyn Future<Output = Result<PinResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn hosted_stores_unpin<'life0, 'async_trait>(
        &'life0 self,
        params: UnpinParams,
    ) -> Pin<Box<dyn Future<Output = Result<UnpinResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn hosted_stores_status<'life0, 'async_trait>(
        &'life0 self,
        params: HostedStoreStatusParams,
    ) -> Pin<Box<dyn Future<Output = Result<HostedStoreStatusResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sync_status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<SyncStatusResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sync_trigger<'life0, 'async_trait>(
        &'life0 self,
        params: SyncTriggerParams,
    ) -> Pin<Box<dyn Future<Output = Result<SyncTriggerResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn updater_status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn updater_set_channel<'life0, 'async_trait>(
        &'life0 self,
        params: SetChannelParams,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn updater_pause<'life0, 'async_trait>(
        &'life0 self,
        params: PauseParams,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn updater_resume<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn updater_check_now<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn pairing_list<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn pairing_approve<'life0, 'async_trait>(
        &'life0 self,
        params: ApproveParams,
    ) -> Pin<Box<dyn Future<Output = Result<PairingApproveResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn pairing_revoke<'life0, 'async_trait>(
        &'life0 self,
        params: RevokeParams,
    ) -> Pin<Box<dyn Future<Output = Result<PairingRevokeResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn peer_status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn peers_connect<'life0, 'async_trait>(
        &'life0 self,
        params: PeersConnectParams,
    ) -> Pin<Box<dyn Future<Output = Result<PeersConnectResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn peers_disconnect<'life0, 'async_trait>(
        &'life0 self,
        params: PeersDisconnectParams,
    ) -> Pin<Box<dyn Future<Output = Result<PeersDisconnectResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn subscribe<'life0, 'async_trait>(
        &'life0 self,
        params: SubscribeParams,
    ) -> Pin<Box<dyn Future<Output = Result<SubscribeResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn unsubscribe<'life0, 'async_trait>(
        &'life0 self,
        params: UnsubscribeParams,
    ) -> Pin<Box<dyn Future<Output = Result<UnsubscribeResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_subscriptions<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<ListSubscriptionsResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_balance<'life0, 'async_trait>(
        &'life0 self,
        params: WalletBalanceParams,
    ) -> Pin<Box<dyn Future<Output = Result<WalletBalanceResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_coins<'life0, 'async_trait>(
        &'life0 self,
        params: WalletCoinsParams,
    ) -> Pin<Box<dyn Future<Output = Result<WalletCoinsResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_coin_by_id<'life0, 'async_trait>(
        &'life0 self,
        params: WalletCoinByIdParams,
    ) -> Pin<Box<dyn Future<Output = Result<WalletCoinByIdResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_arrivals<'life0, 'async_trait>(
        &'life0 self,
        params: WalletArrivalsParams,
    ) -> Pin<Box<dyn Future<Output = Result<WalletArrivalsResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_peak<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<WalletPeakResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn peer_counts<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<PeerCountsResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_sync_status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<WalletSyncStatusResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn wallet_broadcast<'life0, 'async_trait>(
        &'life0 self,
        params: WalletBroadcastParams,
    ) -> Pin<Box<dyn Future<Output = Result<WalletBroadcastResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn pairing_request<'life0, 'async_trait>(
        &'life0 self,
        params: RequestParams,
    ) -> Pin<Box<dyn Future<Output = Result<PairingRequestResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn pairing_poll<'life0, 'async_trait>(
        &'life0 self,
        params: PollParams,
    ) -> Pin<Box<dyn Future<Output = Result<PairingPollResult, ControlError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn dispatch<'life0, 'async_trait>(
        &'life0 self,
        request: JsonRpcRequest,
    ) -> Pin<Box<dyn Future<Output = JsonRpcResponse> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }

}
Expand description

The node-facing half of the contract: a running node implements this to SERVE the control surface. Each method is typed to the catalog’s params/results; the provided dispatch routes a raw JsonRpcRequest to the right method so a server needs only one entry point and can never mis-route.

Open/proxied shapes (the updater beacon status, the pairing list, the peer-pool snapshot) return Value rather than a frozen struct, matching the catalog’s ControlCall::Output for those methods.

Required Methods§

Source

fn status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.status

Source

fn config_get<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ConfigResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.config.get

Source

fn config_set_upstream<'life0, 'async_trait>( &'life0 self, params: SetUpstreamParams, ) -> Pin<Box<dyn Future<Output = Result<SetUpstreamResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.config.setUpstream

Source

fn log_set_level<'life0, 'async_trait>( &'life0 self, params: SetLevelParams, ) -> Pin<Box<dyn Future<Output = Result<SetLevelResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.log.setLevel

Source

fn cache_get<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CacheView, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.cache.get

Source

fn cache_set_cap<'life0, 'async_trait>( &'life0 self, params: SetCapParams, ) -> Pin<Box<dyn Future<Output = Result<SetCapResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.cache.setCap

Source

fn cache_clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CacheClearResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.cache.clear

Source

fn hosted_stores_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HostedStoresListResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.hostedStores.list

Source

fn hosted_stores_pin<'life0, 'async_trait>( &'life0 self, params: PinParams, ) -> Pin<Box<dyn Future<Output = Result<PinResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.hostedStores.pin

Source

fn hosted_stores_unpin<'life0, 'async_trait>( &'life0 self, params: UnpinParams, ) -> Pin<Box<dyn Future<Output = Result<UnpinResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.hostedStores.unpin

Source

fn hosted_stores_status<'life0, 'async_trait>( &'life0 self, params: HostedStoreStatusParams, ) -> Pin<Box<dyn Future<Output = Result<HostedStoreStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.hostedStores.status

Source

fn sync_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SyncStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.sync.status

Source

fn sync_trigger<'life0, 'async_trait>( &'life0 self, params: SyncTriggerParams, ) -> Pin<Box<dyn Future<Output = Result<SyncTriggerResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.sync.trigger

Source

fn updater_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.updater.status

Source

fn updater_set_channel<'life0, 'async_trait>( &'life0 self, params: SetChannelParams, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.updater.setChannel

Source

fn updater_pause<'life0, 'async_trait>( &'life0 self, params: PauseParams, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.updater.pause

Source

fn updater_resume<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.updater.resume

Source

fn updater_check_now<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.updater.checkNow

Source

fn pairing_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.pairing.list

Source

fn pairing_approve<'life0, 'async_trait>( &'life0 self, params: ApproveParams, ) -> Pin<Box<dyn Future<Output = Result<PairingApproveResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.pairing.approve

Source

fn pairing_revoke<'life0, 'async_trait>( &'life0 self, params: RevokeParams, ) -> Pin<Box<dyn Future<Output = Result<PairingRevokeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.pairing.revoke

Source

fn peer_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.peerStatus

Source

fn peers_connect<'life0, 'async_trait>( &'life0 self, params: PeersConnectParams, ) -> Pin<Box<dyn Future<Output = Result<PeersConnectResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.peers.connect

Source

fn peers_disconnect<'life0, 'async_trait>( &'life0 self, params: PeersDisconnectParams, ) -> Pin<Box<dyn Future<Output = Result<PeersDisconnectResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.peers.disconnect

Source

fn subscribe<'life0, 'async_trait>( &'life0 self, params: SubscribeParams, ) -> Pin<Box<dyn Future<Output = Result<SubscribeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.subscribe

Source

fn unsubscribe<'life0, 'async_trait>( &'life0 self, params: UnsubscribeParams, ) -> Pin<Box<dyn Future<Output = Result<UnsubscribeResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.unsubscribe

Source

fn list_subscriptions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ListSubscriptionsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.listSubscriptions

Source

fn wallet_balance<'life0, 'async_trait>( &'life0 self, params: WalletBalanceParams, ) -> Pin<Box<dyn Future<Output = Result<WalletBalanceResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.balance (READ-only)

Source

fn wallet_coins<'life0, 'async_trait>( &'life0 self, params: WalletCoinsParams, ) -> Pin<Box<dyn Future<Output = Result<WalletCoinsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.coins (READ-only, OPEN)

An empty coins list MUST mean “a chain was consulted and this address holds nothing”. A read that could not consult a chain MUST return the matching catalogued error instead.

Source

fn wallet_coin_by_id<'life0, 'async_trait>( &'life0 self, params: WalletCoinByIdParams, ) -> Pin<Box<dyn Future<Output = Result<WalletCoinByIdResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.coinById (READ-only, OPEN)

Ok(coin: None) MUST mean “a chain was consulted and holds no such coin”. A read that could not consult a chain MUST return the matching catalogued error instead — a caller that cannot tell those apart reports a spent mint as pending forever.

The params are validated at DESERIALIZATION (lowercase 64-hex, 0x stripped), so any path that decodes WalletCoinByIdParams refuses malformed ids as INVALID_PARAMS before this method is called.

Source

fn wallet_arrivals<'life0, 'async_trait>( &'life0 self, params: WalletArrivalsParams, ) -> Pin<Box<dyn Future<Output = Result<WalletArrivalsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.arrivals (READ-only, TOKEN-GATED)

Gated although it is a read: the caller supplies only a cursor, so the answer names this node’s OWN watched puzzle hashes and the receive history behind them.

Every returned row MUST be a CONFIRMED arrival that the node itself judged: above its arrival baseline, not previously reported, and not the wallet’s own change. An implementation MUST NOT emit a mempool sighting here, and MUST answer an empty page rather than an error when it has no baseline — “nothing arrived” is the honest answer from a wallet that cannot yet tell history from news.

cursor MUST be the position of the last row actually returned (or the caller’s after_seq for an empty page) and MUST NOT be latest; see WalletArrivalsResult::latest.

Source

fn wallet_peak<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WalletPeakResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.peak (READ-only, OPEN)

Source

fn peer_counts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PeerCountsResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.peerCounts (READ-only, OPEN)

dig_peer_count MUST be dig-node-core’s connected_peers — the same figure control.peerStatus reports — and chia_peer_count MUST be the SAME observation wallet_sync_status reports, served from ONE source so the two answers agree. None means the count cannot be observed; a network that is not running is UNKNOWN, never Some(0).

Source

fn wallet_sync_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WalletSyncStatusResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.syncStatus (READ-only, OPEN)

WalletSyncPhase::Synced MUST require BOTH that the initial catch-up completed and that at least one Chia peer connection is live now, which makes it strictly stronger than WalletPeakResult::synced. peak_height MUST be the node’s OWN replica’s height or None, never an oracle’s, and chia_peer_count counts CHIA full-node peers – never DIG peers.

Source

fn wallet_broadcast<'life0, 'async_trait>( &'life0 self, params: WalletBroadcastParams, ) -> Pin<Box<dyn Future<Output = Result<WalletBroadcastResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

control.wallet.broadcast (TOKEN-GATED)

Pushes an ALREADY-SIGNED bundle: the implementation never signs, and never receives anything it could sign with (§908). A mempool refusal is Ok with accepted: false; failing to reach a mempool is Err.

Source

fn pairing_request<'life0, 'async_trait>( &'life0 self, params: RequestParams, ) -> Pin<Box<dyn Future<Output = Result<PairingRequestResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

pairing.request (OPEN)

Source

fn pairing_poll<'life0, 'async_trait>( &'life0 self, params: PollParams, ) -> Pin<Box<dyn Future<Output = Result<PairingPollResult, ControlError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

pairing.poll (OPEN)

Provided Methods§

Source

fn dispatch<'life0, 'async_trait>( &'life0 self, request: JsonRpcRequest, ) -> Pin<Box<dyn Future<Output = JsonRpcResponse> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Route a raw JSON-RPC request to the right typed method and build the response envelope.

Deserializes the params for methods that take them, calls the handler, and serializes the typed result. An unknown method → METHOD_NOT_FOUND; malformed params → INVALID_PARAMS. This is the single seam a server dispatches through — the KATs exercise it end-to-end.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§