fedimint_ln_client

Struct LightningClientModule

source
pub struct LightningClientModule {
    pub cfg: LightningClientConfig,
    pub(crate) notifier: ModuleNotifier<LightningClientStateMachines>,
    pub(crate) redeem_key: KeyPair,
    pub(crate) secp: Secp256k1<All>,
    pub(crate) module_api: DynModuleApi,
    pub(crate) preimage_auth: KeyPair,
    pub(crate) client_ctx: ClientContext<Self>,
    pub(crate) update_gateway_cache_merge: UpdateMerge,
    pub(crate) gateway_conn: Arc<dyn GatewayConnection + Send + Sync>,
}
Expand description

Client side lightning module

Note that lightning gateways use a different version of client side module.

Fields§

§cfg: LightningClientConfig§notifier: ModuleNotifier<LightningClientStateMachines>§redeem_key: KeyPair§secp: Secp256k1<All>§module_api: DynModuleApi§preimage_auth: KeyPair§client_ctx: ClientContext<Self>§update_gateway_cache_merge: UpdateMerge§gateway_conn: Arc<dyn GatewayConnection + Send + Sync>

Implementations§

source§

impl LightningClientModule

source

pub(crate) fn new( args: &ClientModuleInitArgs<LightningClientInit>, gateway_conn: Arc<dyn GatewayConnection + Send + Sync>, ) -> Self

source

pub(crate) async fn get_prev_payment_result( &self, payment_hash: &Hash, dbtx: &mut DatabaseTransaction<'_>, ) -> PaymentResult

source

pub(crate) fn get_payment_operation_id( payment_hash: &Hash, index: u16, ) -> OperationId

source

pub(crate) fn get_preimage_authentication(&self, payment_hash: &Hash) -> Hash

Hashes the client’s preimage authentication secret with the provided payment_hash. The resulting hash is used when contacting the gateway to determine if this client is allowed to be shown the preimage.

source

pub(crate) async fn create_outgoing_output<'a, 'b>( &'a self, operation_id: OperationId, invoice: Bolt11Invoice, gateway: LightningGateway, fed_id: FederationId, rng: impl RngCore + CryptoRng + 'a, ) -> Result<(ClientOutput<LightningOutputV0, LightningClientStateMachines>, ContractId)>

Create an output that incentivizes a Lightning gateway to pay an invoice for us. It has time till the block height defined by timelock, after that we can claim our money back.

source

pub(crate) async fn create_incoming_output( &self, operation_id: OperationId, invoice: Bolt11Invoice, ) -> Result<(ClientOutput<LightningOutputV0, LightningClientStateMachines>, ContractId)>

Create an output that funds an incoming contract within the federation This directly completes a transaction between users, without involving a gateway

source

pub(crate) async fn await_receive_success( &self, operation_id: OperationId, ) -> Result<bool, LightningReceiveError>

Returns a bool indicating if it was an external receive

source

pub(crate) async fn await_claim_acceptance( &self, operation_id: OperationId, ) -> Result<Vec<OutPoint>, LightningReceiveError>

source

pub(crate) fn create_lightning_receive_output<'a>( &'a self, amount: Amount, description: Bolt11InvoiceDescription<'a>, receiving_key: ReceivingKey, rng: impl RngCore + CryptoRng + 'a, expiry_time: Option<u64>, src_node_id: PublicKey, short_channel_id: u64, route_hints: &[RouteHint], network: Network, ) -> Result<(OperationId, Bolt11Invoice, ClientOutput<LightningOutput, LightningClientStateMachines>, [u8; 32])>

source

pub async fn select_gateway( &self, gateway_id: &PublicKey, ) -> Option<LightningGateway>

Selects a Lightning Gateway from a given gateway_id from the gateway cache.

source

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

Updates the gateway cache by fetching the latest registered gateways from the federation.

See also Self::update_gateway_cache_continuously.

source

pub async fn update_gateway_cache_continuously<Fut>( &self, gateways_filter: impl Fn(Vec<LightningGatewayAnnouncement>) -> Fut, ) -> !
where Fut: Future<Output = Vec<LightningGatewayAnnouncement>>,

Continuously update the gateway cache whenever a gateway expires.

The gateways returned by gateway_filters are checked for expiry. Client integrators are expected to call this function in a spawned task.

source

pub async fn list_gateways(&self) -> Vec<LightningGatewayAnnouncement>

Returns all gateways that are currently in the gateway cache.

source

pub async fn pay_bolt11_invoice<M: Serialize + MaybeSend + MaybeSync>( &self, maybe_gateway: Option<LightningGateway>, invoice: Bolt11Invoice, extra_meta: M, ) -> Result<OutgoingLightningPayment>

Pays a LN invoice with our available funds using the supplied gateway if one was provided and the invoice is not an internal one. If none is supplied only internal payments are possible.

The gateway can be acquired by calling LightningClientModule::select_gateway.

Can return error of type PayBolt11InvoiceError

source

pub async fn get_ln_pay_details_for( &self, operation_id: OperationId, ) -> Result<LightningOperationMetaPay>

source

pub async fn subscribe_internal_pay( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<InternalPayState>>

source

pub async fn subscribe_ln_pay( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<LnPayState>>

Subscribes to a stream of updates about a particular external Lightning payment operation specified by the operation_id.

source

pub async fn scan_receive_for_user_tweaked<M: Serialize + Send + Sync + Clone>( &self, key_pair: KeyPair, indices: Vec<u64>, extra_meta: M, ) -> Vec<OperationId>

Scan unspent incoming contracts for a payment hash that matches a tweaked keys in the indices vector

source

pub async fn scan_receive_for_user<M: Serialize + Send + Sync>( &self, key_pair: KeyPair, extra_meta: M, ) -> Result<OperationId>

Scan unspent incoming contracts for a payment hash that matches a public key and claim the incoming contract

source

pub async fn claim_funded_incoming_contract<M: Serialize + Send + Sync>( &self, key_pair: KeyPair, contract_id: ContractId, extra_meta: M, ) -> Result<OperationId>

Claim the funded, unspent incoming contract by submitting a transaction to the federation and awaiting the primary module’s outputs

source

pub async fn create_bolt11_invoice<M: Serialize + Send + Sync>( &self, amount: Amount, description: Bolt11InvoiceDescription<'_>, expiry_time: Option<u64>, extra_meta: M, gateway: Option<LightningGateway>, ) -> Result<(OperationId, Bolt11Invoice, [u8; 32])>

Receive over LN with a new invoice

source

pub async fn create_bolt11_invoice_for_user_tweaked<M: Serialize + Send + Sync>( &self, amount: Amount, description: Bolt11InvoiceDescription<'_>, expiry_time: Option<u64>, user_key: PublicKey, index: u64, extra_meta: M, gateway: Option<LightningGateway>, ) -> Result<(OperationId, Bolt11Invoice, [u8; 32])>

Receive over LN with a new invoice for another user, tweaking their key by the given index

source

pub async fn create_bolt11_invoice_for_user<M: Serialize + Send + Sync>( &self, amount: Amount, description: Bolt11InvoiceDescription<'_>, expiry_time: Option<u64>, user_key: PublicKey, extra_meta: M, gateway: Option<LightningGateway>, ) -> Result<(OperationId, Bolt11Invoice, [u8; 32])>

Receive over LN with a new invoice for another user

source

pub(crate) async fn create_bolt11_invoice_internal<M: Serialize + Send + Sync>( &self, amount: Amount, description: Bolt11InvoiceDescription<'_>, expiry_time: Option<u64>, receiving_key: ReceivingKey, extra_meta: M, gateway: Option<LightningGateway>, ) -> Result<(OperationId, Bolt11Invoice, [u8; 32])>

Receive over LN with a new invoice

source

pub async fn subscribe_ln_claim( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<LnReceiveState>>

source

pub async fn subscribe_ln_receive( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<LnReceiveState>>

source

pub async fn get_gateway( &self, gateway_id: Option<PublicKey>, force_internal: bool, ) -> Result<Option<LightningGateway>>

Returns a gateway to be used for a lightning operation. If force_internal is true and no gateway_id is specified, no gateway will be selected.

source

pub async fn wait_for_ln_payment( &self, payment_type: PayType, contract_id: ContractId, return_on_funding: bool, ) -> Result<Option<Value>>

Trait Implementations§

source§

impl ClientModule for LightningClientModule

source§

type Init = LightningClientInit

source§

type Common = LightningModuleTypes

Common module types shared between client and server
source§

type Backup = NoModuleBackup

Data stored in regular backups so that restoring doesn’t have to start from epoch 0
source§

type ModuleStateMachineContext = LightningClientContext

Data and API clients available to state machine transitions of this module
source§

type States = LightningClientStateMachines

All possible states this client can submit to the executor
source§

fn context(&self) -> Self::ModuleStateMachineContext

source§

fn input_fee( &self, _amount: Amount, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amount>

Returns the fee the processing of this input requires. Read more
source§

fn output_fee( &self, output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amount>

Returns the fee the processing of this output requires. Read more
source§

fn handle_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn handle_rpc<'life0, 'async_trait>( &'life0 self, method: String, payload: Value, ) -> Pin<Box<dyn Future<Output = BoxStream<'_, Result<Value>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

source§

fn decoder() -> Decoder

source§

fn kind() -> ModuleKind

source§

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Initialize client. Read more
source§

fn supports_backup(&self) -> bool

source§

fn backup<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::Backup, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

source§

fn supports_being_primary(&self) -> bool

Does this module support being a primary module Read more
source§

fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, _operation_id: OperationId, _input_amount: Amount, _output_amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<(Vec<ClientInput<<Self::Common as ModuleCommon>::Input, Self::States>>, Vec<ClientOutput<<Self::Common as ModuleCommon>::Output, Self::States>>), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Creates all inputs and outputs necessary to balance the transaction. The function returns an error if and only if the client’s funds are not sufficient to create the inputs necessary to fully fund the transaction. Read more
source§

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, _operation_id: OperationId, _out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<Amount, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Waits for the funds from an output created by Self::create_final_inputs_and_outputs to become available. This function returning typically implies a change in the output of Self::get_balance.
source§

fn get_balance<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Returns the balance held by this module and available for funding transactions.
source§

fn subscribe_balance_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = ()> + Send>>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns a stream that will output the updated module balance each time it changes.
source§

fn leave<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Leave the federation Read more
source§

impl Debug for LightningClientModule

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

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 + Sync + Send>

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

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> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
source§

impl<T> IClientModule for T
where T: ClientModule,

source§

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

source§

fn decoder(&self) -> Decoder

source§

fn context(&self, instance: u16) -> DynContext

source§

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

source§

fn handle_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait,

source§

fn handle_rpc<'life0, 'async_trait>( &'life0 self, method: String, request: Value, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = Result<Value, Error>> + Send + 'life0>>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

source§

fn input_fee(&self, amount: Amount, input: &DynInput) -> Option<Amount>

source§

fn output_fee(&self, output: &DynOutput) -> Option<Amount>

source§

fn supports_backup(&self) -> bool

source§

fn backup<'life0, 'async_trait>( &'life0 self, module_instance_id: u16, ) -> Pin<Box<dyn Future<Output = Result<DynModuleBackup, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

source§

fn supports_being_primary(&self) -> bool

source§

fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, module_instance: u16, dbtx: &'life1 mut DatabaseTransaction<'life2>, operation_id: OperationId, input_amount: Amount, output_amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<(Vec<ClientInput>, Vec<ClientOutput>), Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: 'async_trait,

source§

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, operation_id: OperationId, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<Amount, Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

source§

fn get_balance<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, module_instance: u16, dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, T: 'async_trait,

source§

fn subscribe_balance_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = ()> + Send>>> + Send + 'async_trait>>
where 'life0: 'async_trait, T: 'async_trait,

§

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.

source§

impl<T> IntoRequest<T> for T

source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

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

source§

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.
§

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>,

source§

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>,

source§

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
source§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

source§

impl<T> MaybeSync for T
where T: Sync,