pub struct TorClient<R: Runtime> {
Show 23 fields runtime: R, client_isolation: IsolationToken, connect_prefs: StreamPrefs, chanmgr: Arc<ChanMgr<R>>, circmgr: Arc<CircMgr<R>>, dirmgr_store: DirMgrStore<R>, dirmgr: Arc<dyn DirProvider>, bridge_desc_mgr: Arc<Mutex<Option<Arc<BridgeDescMgr<R>>>>>, pt_mgr: Arc<PtMgr<R>>, hsclient: HsClientConnector<R>, hs_circ_pool: Arc<HsCircPool<R>>, keymgr: Option<Arc<KeyMgr>>, guardmgr: GuardMgr<R>, state_dir: PathBuf, storage_mistrust: Mistrust, statemgr: FsStateMgr, addrcfg: Arc<MutCfg<ClientAddrConfig>>, timeoutcfg: Arc<MutCfg<StreamTimeoutConfig>>, reconfigure_lock: Arc<Mutex<()>>, status_receiver: BootstrapEvents, bootstrap_in_progress: Arc<Mutex<()>>, should_bootstrap: BootstrapBehavior, dormant: Arc<Mutex<DropNotifyWatchSender<Option<DormantMode>>>>,
}
Expand description

An active client session on the Tor network.

While it’s running, it will fetch directory information, build circuits, and make connections for you.

Cloning this object makes a new reference to the same underlying handles: it’s usually better to clone the TorClient than it is to create a new one.

Fields§

§runtime: R

Asynchronous runtime object.

§client_isolation: IsolationToken

Default isolation token for streams through this client.

This is eventually used for owner_token in tor-circmgr/src/usage.rs, and is orthogonal to the stream_isolation which comes from connect_prefs (or a passed-in StreamPrefs). (ie, both must be the same to share a circuit).

§connect_prefs: StreamPrefs

Connection preferences. Starts out as Default, Inherited by our clones.

§chanmgr: Arc<ChanMgr<R>>

Channel manager, used by circuits etc.,

Used directly by client only for reconfiguration.

§circmgr: Arc<CircMgr<R>>

Circuit manager for keeping our circuits up to date and building them on-demand.

§dirmgr_store: DirMgrStore<R>

Directory manager persistent storage.

§dirmgr: Arc<dyn DirProvider>

Directory manager for keeping our directory material up to date.

§bridge_desc_mgr: Arc<Mutex<Option<Arc<BridgeDescMgr<R>>>>>
Available on crate feature bridge-client only.

Bridge descriptor manager

None until we have bootstrapped.

Lock hierarchy: don’t acquire this before dormant

§pt_mgr: Arc<PtMgr<R>>
Available on crate feature pt-client only.

Pluggable transport manager.

§hsclient: HsClientConnector<R>
Available on crate feature onion-service-client only.

HS client connector

§hs_circ_pool: Arc<HsCircPool<R>>
Available on crate feature onion-service-service only.

Circuit pool for providing onion services with circuits.

§keymgr: Option<Arc<KeyMgr>>

The key manager.

This is used for retrieving private keys, certificates, and other sensitive data (for example, for retrieving the keys necessary for connecting to hidden services that require client authentication).

If this crate is compiled with the keymgr feature, TorClient will use a functional key manager implementation.

If this crate is compiled without the keymgr feature, then TorClient will use a no-op key manager implementation instead.

See the [KeyMgr] documentation for more details.

§guardmgr: GuardMgr<R>

Guard manager

§state_dir: PathBuf
Available on crate feature onion-service-service only.

Location on disk where we store persistent data (raw directory).

§storage_mistrust: Mistrust
Available on crate feature onion-service-service only.

Permissions Mistrust configuration for all our on-disk storage

This applies to state_dir, but it comes from [storage] in our config, so this configuration is the same one as used for eg the netdir cache. (It’s mostly copied during TorClient creation, and ends up within the subsystems in fields like dirmgr, keymgr and statemgr.)

§statemgr: FsStateMgr

Location on disk where we store persistent data (cooked state manager).

§addrcfg: Arc<MutCfg<ClientAddrConfig>>

Client address configuration

§timeoutcfg: Arc<MutCfg<StreamTimeoutConfig>>

Client DNS configuration

§reconfigure_lock: Arc<Mutex<()>>

Mutex used to serialize concurrent attempts to reconfigure a TorClient.

See TorClient::reconfigure for more information on its use.

§status_receiver: BootstrapEvents

A stream of bootstrap messages that we can clone when a client asks for it.

(We don’t need to observe this stream ourselves, since it drops each unobserved status change when the next status change occurs.)

§bootstrap_in_progress: Arc<Mutex<()>>

mutex used to prevent two tasks from trying to bootstrap at once.

§should_bootstrap: BootstrapBehavior

Whether or not we should call bootstrap before doing things that require bootstrapping. If this is false, we will just call wait_for_bootstrap instead.

§dormant: Arc<Mutex<DropNotifyWatchSender<Option<DormantMode>>>>

Shared boolean for whether we’re currently in “dormant mode” or not.

Implementations§

source§

impl TorClient<PreferredRuntime>

source

pub async fn create_bootstrapped(config: TorClientConfig) -> Result<Self>

Available on (crate features native-tls or rustls) and (crate features async-std or tokio) only.

Bootstrap a connection to the Tor network, using the provided config.

Returns a client once there is enough directory material to connect safely over the Tor network.

Consider using TorClient::builder for more fine-grained control.

§Panics

If Tokio is being used (the default), panics if created outside the context of a currently running Tokio runtime. See the documentation for [PreferredRuntime::current] for more information.

If using async-std, either take care to ensure Arti is not compiled with Tokio support, or manually create an async-std runtime using [tor_rtcompat] and use it with TorClient::with_runtime.

source

pub fn builder() -> TorClientBuilder<PreferredRuntime>

Available on (crate features native-tls or rustls) and (crate features async-std or tokio) only.

Return a new builder for creating TorClient objects.

If you want to make a TorClient synchronously, this is what you want; call TorClientBuilder::create_unbootstrapped on the returned builder.

§Panics

If Tokio is being used (the default), panics if created outside the context of a currently running Tokio runtime. See the documentation for tokio::runtime::Handle::current for more information.

If using async-std, either take care to ensure Arti is not compiled with Tokio support, or manually create an async-std runtime using [tor_rtcompat] and use it with TorClient::with_runtime.

source§

impl<R: Runtime> TorClient<R>

source

pub fn with_runtime(runtime: R) -> TorClientBuilder<R>

Return a new builder for creating TorClient objects, with a custom provided [Runtime].

See the [tor_rtcompat] crate for more information on custom runtimes.

source

pub(crate) fn create_inner( runtime: R, config: &TorClientConfig, autobootstrap: BootstrapBehavior, dirmgr_builder: &dyn DirProviderBuilder<R>, dirmgr_extensions: DirMgrExtensions ) -> StdResult<Self, ErrorDetail>

Implementation of create_unbootstrapped, split out in order to avoid manually specifying double error conversions.

source

pub async fn bootstrap(&self) -> Result<()>

Bootstrap a connection to the Tor network, with a client created by create_unbootstrapped.

Since cloned copies of a TorClient share internal state, you can bootstrap a client by cloning it and running this function in a background task (or similar). This function only needs to be called on one client in order to bootstrap all of its clones.

Returns once there is enough directory material to connect safely over the Tor network. If the client or one of its clones has already been bootstrapped, returns immediately with success. If a bootstrap is in progress, waits for it to finish, then retries it if it failed (returning success if it succeeded).

Bootstrap progress can be tracked by listening to the event receiver returned by bootstrap_events.

§Failures

If the bootstrapping process fails, returns an error. This function can safely be called again later to attempt to bootstrap another time.

source

async fn bootstrap_inner(&self) -> StdResult<(), ErrorDetail>

Implementation of bootstrap, split out in order to avoid manually specifying double error conversions.

source

async fn wait_for_bootstrap(&self) -> StdResult<(), ErrorDetail>

§For BootstrapBehavior::OnDemand clients

Initiate a bootstrap by calling bootstrap (which is idempotent, so attempts to bootstrap twice will just do nothing).

§For BootstrapBehavior::Manual clients

Check whether a bootstrap is in progress; if one is, wait until it finishes and then return. (Otherwise, return immediately.)

source

pub fn reconfigure( &self, new_config: &TorClientConfig, how: Reconfigure ) -> Result<()>

Change the configuration of this TorClient to new_config.

The how describes whether to perform an all-or-nothing reconfiguration: either all of the configuration changes will be applied, or none will. If you have disabled all-or-nothing changes, then only fatal errors will be reported in this function’s return value.

This function applies its changes to all TorClient instances derived from the same call to TorClient::create_*: even ones whose circuits are isolated from this handle.

§Limitations

Although most options are reconfigurable, there are some whose values can’t be changed on an a running TorClient. Those options (or their sections) are explicitly documented not to be changeable.

Changing some options do not take effect immediately on all open streams and circuits, but rather affect only future streams and circuits. Those are also explicitly documented.

source

fn reconfigure_inner( &self, new_config: &TorClientConfig, how: Reconfigure, _reconfigure_lock_guard: &MutexGuard<'_, ()> ) -> Result<()>

This is split out from reconfigure so we can do the all-or-nothing check without recursion. the caller to this method must hold the reconfigure_lock.

source

pub fn isolated_client(&self) -> TorClient<R>

Return a new isolated TorClient handle.

The two TorClients will share internal state and configuration, but their streams will never share circuits with one another.

Use this function when you want separate parts of your program to each have a TorClient handle, but where you don’t want their activities to be linkable to one another over the Tor network.

Calling this function is usually preferable to creating a completely separate TorClient instance, since it can share its internals with the existing TorClient.

(Connections made with clones of the returned TorClient may share circuits with each other.)

source

pub async fn connect<A: IntoTorAddr>(&self, target: A) -> Result<DataStream>

Launch an anonymized connection to the provided address and port over the Tor network.

Note that because Tor prefers to do DNS resolution on the remote side of the network, this function takes its address as a string:

// The most usual way to connect is via an address-port tuple.
let socket = tor_client.connect(("www.example.com", 443)).await?;

// You can also specify an address and port as a colon-separated string.
let socket = tor_client.connect("www.example.com:443").await?;

Hostnames are strongly preferred here: if this function allowed the caller here to provide an IPAddr or IpAddr or SocketAddr address, then

// BAD: We're about to leak our target address to the local resolver!
let address = "www.example.com:443".to_socket_addrs().unwrap().next().unwrap();
// 🤯 Oh no! Now any eavesdropper can tell where we're about to connect! 🤯

// Fortunately, this won't compile, since SocketAddr doesn't implement IntoTorAddr.
// let socket = tor_client.connect(address).await?;
//                                 ^^^^^^^ the trait `IntoTorAddr` is not implemented for `std::net::SocketAddr`

If you really do need to connect to an IP address rather than a hostname, and if you’re sure that the IP address came from a safe location, there are a few ways to do so.

// ⚠️This is risky code!⚠️
// (Make sure your addresses came from somewhere safe...)

// If we have a fixed address, we can just provide it as a string.
let socket = tor_client.connect("192.0.2.22:443").await?;
let socket = tor_client.connect(("192.0.2.22", 443)).await?;

// If we have a SocketAddr or an IpAddr, we can use the
// DangerouslyIntoTorAddr trait.
use arti_client::DangerouslyIntoTorAddr;
let sockaddr = SocketAddr::from(([192, 0, 2, 22], 443));
let ipaddr = IpAddr::from([192, 0, 2, 22]);
let socket = tor_client.connect(sockaddr.into_tor_addr_dangerously().unwrap()).await?;
let socket = tor_client.connect((ipaddr, 443).into_tor_addr_dangerously().unwrap()).await?;
source

pub async fn connect_with_prefs<A: IntoTorAddr>( &self, target: A, prefs: &StreamPrefs ) -> Result<DataStream>

Launch an anonymized connection to the provided address and port over the Tor network, with explicit connection preferences.

Note that because Tor prefers to do DNS resolution on the remote side of the network, this function takes its address as a string. (See TorClient::connect() for more information.)

source

pub fn set_stream_prefs(&mut self, connect_prefs: StreamPrefs)

Sets the default preferences for future connections made with this client.

The preferences set with this function will be inherited by clones of this client, but updates to the preferences in those clones will not propagate back to the original. I.e., the preferences are copied by clone.

Connection preferences always override configuration, even configuration set later (eg, by a config reload).

source

pub fn clone_with_prefs(&self, connect_prefs: StreamPrefs) -> Self

Provides a new handle on this client, but with adjusted default preferences.

Connections made with e.g. connect on the returned handle will use connect_prefs. This is a convenience wrapper for clone and set_connect_prefs.

source

pub async fn resolve(&self, hostname: &str) -> Result<Vec<IpAddr>>

On success, return a list of IP addresses.

source

pub async fn resolve_with_prefs( &self, hostname: &str, prefs: &StreamPrefs ) -> Result<Vec<IpAddr>>

On success, return a list of IP addresses, but use prefs.

source

pub async fn resolve_ptr(&self, addr: IpAddr) -> Result<Vec<String>>

Perform a remote DNS reverse lookup with the provided IP address.

On success, return a list of hostnames.

source

pub async fn resolve_ptr_with_prefs( &self, addr: IpAddr, prefs: &StreamPrefs ) -> Result<Vec<String>>

Perform a remote DNS reverse lookup with the provided IP address.

On success, return a list of hostnames.

source

pub fn dirmgr(&self) -> &Arc<dyn DirProvider>

Available on crate feature experimental-api only.

Return a reference to this client’s directory manager.

This function is unstable. It is only enabled if the crate was built with the experimental-api feature.

source

pub fn circmgr(&self) -> &Arc<CircMgr<R>>

Available on crate feature experimental-api only.

Return a reference to this client’s circuit manager.

This function is unstable. It is only enabled if the crate was built with the experimental-api feature.

source

pub fn chanmgr(&self) -> &Arc<ChanMgr<R>>

Available on crate feature experimental-api only.

Return a reference to this client’s channel manager.

This function is unstable. It is only enabled if the crate was built with the experimental-api feature.

source

pub fn runtime(&self) -> &R

Return a reference to the runtime being used by this client.

source

fn netdir( &self, timeliness: Timeliness, action: &'static str ) -> StdResult<Arc<NetDir>, ErrorDetail>

Return a netdir that is timely according to the rules of timeliness.

The action string is a description of what we wanted to do with the directory, to be put into the error message if we couldn’t find a directory.

source

async fn get_or_launch_exit_circ( &self, exit_ports: &[TargetPort], prefs: &StreamPrefs ) -> StdResult<Arc<ClientCirc>, ErrorDetail>

Get or launch an exit-suitable circuit with a given set of exit ports.

source

fn isolation(&self, prefs: &StreamPrefs) -> StreamIsolation

Return an overall Isolation for this TorClient and a StreamPrefs.

This describes which operations might use circuit(s) with this one.

This combines isolation information from StreamPrefs::prefs_isolation and the TorClient’s isolation (eg from TorClient::isolated_client).

source

pub fn launch_onion_service( &self, config: OnionServiceConfig ) -> Result<(Arc<RunningOnionService>, impl Stream<Item = RendRequest>)>

Available on crate feature onion-service-service only.

Try to launch an onion service with a given configuration.

This onion service will not actually handle any requests on its own: you will need to pull RendRequest objects from the returned stream, accept the ones that you want to answer, and then wait for them to give you StreamRequests.

You may find the [tor_hsservice::handle_rend_requests] API helpful for translating RendRequests into StreamRequests.

If you want to forward all the requests from an onion service to a set of local ports, you may want to use the tor-hsrproxy crate.

source

pub fn create_onion_service( config: &TorClientConfig, svc_config: OnionServiceConfig ) -> Result<OnionService>

Available on crate feature onion-service-service only.

Create (but do not launch) a new OnionService using the given configuration.

The returned OnionService can be launched using OnionService::launch().

source

pub fn bootstrap_status(&self) -> BootstrapStatus

Return a current status::BootstrapStatus describing how close this client is to being ready for user traffic.

source

pub fn bootstrap_events(&self) -> BootstrapEvents

Return a stream of status::BootstrapStatus events that will be updated whenever the client’s status changes.

The receiver might not receive every update sent to this stream, though when it does poll the stream it should get the most recent one.

source

pub fn set_dormant(&self, mode: DormantMode)

Change the client’s current dormant mode, putting background tasks to sleep or waking them up as appropriate.

This can be used to conserve CPU usage if you aren’t planning on using the client for a while, especially on mobile platforms.

See the DormantMode documentation for more details.

source

fn create_keymgr( config: &TorClientConfig ) -> StdResult<Option<Arc<KeyMgr>>, ErrorDetail>

Create a [KeyMgr] using the specified configuration.

Returns Ok(None) if keystore use is disabled.

source

fn state_dir( config: &TorClientConfig ) -> StdResult<(PathBuf, &Mistrust), ErrorDetail>

Get the state directory and its corresponding Mistrust configuration.

Trait Implementations§

source§

impl<R: Clone + Runtime> Clone for TorClient<R>

source§

fn clone(&self) -> TorClient<R>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl HasConstTypeId_ for TorClient<PreferredRuntime>

Available on crate feature rpc only.
source§

impl<R> Object for TorClient<R>
where R: Runtime,

Available on crate feature rpc only.
source§

fn expose_outside_of_session(&self) -> bool

Return true if this object should be given an identifier that allows it to be used outside of the session that generated it. Read more
source§

fn get_cast_table(&self) -> &CastTable

Return a CastTable that can be used to downcast a dyn Object of this type into various kinds of dyn Trait references. Read more

Auto Trait Implementations§

§

impl<R> !RefUnwindSafe for TorClient<R>

§

impl<R> Send for TorClient<R>

§

impl<R> Sync for TorClient<R>

§

impl<R> Unpin for TorClient<R>
where R: Unpin,

§

impl<R> !UnwindSafe for TorClient<R>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where T: Clone,

§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more