pub struct Client { /* private fields */ }
Expand description
Client API implementation to store and get data.
Implementations§
source§impl Client
impl Client
sourcepub async fn quick_start(peers: Option<Vec<Multiaddr>>) -> Result<Self, Error>
pub async fn quick_start(peers: Option<Vec<Multiaddr>>) -> Result<Self, Error>
A quick client with a random secret key and some peers.
sourcepub async fn new(
signer: SecretKey,
peers: Option<Vec<Multiaddr>>,
connection_timeout: Option<Duration>,
client_event_broadcaster: Option<ClientEventsBroadcaster>
) -> Result<Self, Error>
pub async fn new( signer: SecretKey, peers: Option<Vec<Multiaddr>>, connection_timeout: Option<Duration>, client_event_broadcaster: Option<ClientEventsBroadcaster> ) -> Result<Self, Error>
Instantiate a new client.
Optionally specify the duration for the connection timeout.
Defaults to 180 seconds.
§Arguments
- ‘signer’ - SecretKey
- ‘peers’ - Option<Vec<Multiaddr>>
- ‘connection_timeout’ - Option<Duration> : Specification for client connection timeout set via Optional
- ‘client_event_broadcaster’ - Option<ClientEventsBroadcaster>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
let client = Client::new(SecretKey::random(), None, None, None).await?;
sourcepub fn events_channel(&self) -> ClientEventsReceiver
pub fn events_channel(&self) -> ClientEventsReceiver
Get the client events channel.
Return Type:
§Example
use sn_client::{Client, Error, ClientEvent};
use bls::SecretKey;
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Using client.events_channel() to publish messages
let mut events_channel = client.events_channel();
while let Ok(event) = events_channel.recv().await {
// Handle the event
}
sourcepub fn sign<T: AsRef<[u8]>>(&self, data: T) -> Signature
pub fn sign<T: AsRef<[u8]>>(&self, data: T) -> Signature
Sign the given data.
§Arguments
- ‘data’ - bytes; i.e bytes of an sn_registers::Register instance
Return Type:
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use tracing::callsite::register;
use xor_name::XorName;
use sn_registers::Register;
use sn_protocol::messages::RegisterCmd;
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Set up register prerequisites
let mut rng = rand::thread_rng();
let xorname = XorName::random(&mut rng);
let owner_sk = SecretKey::random();
let owner_pk = owner_sk.public_key();
// set up register
let mut register = Register::new(owner_pk, xorname, Default::default());
let mut register_clone = register.clone();
// Use of client.sign() with register through RegisterCmd::Create
let cmd = RegisterCmd::Create {
register,
signature: client.sign(register_clone.bytes()?),
};
sourcepub fn set_signer_key(&mut self, sk: SecretKey)
pub fn set_signer_key(&mut self, sk: SecretKey)
sourcepub async fn get_signed_register_from_network(
&self,
address: RegisterAddress,
is_verifying: bool
) -> Result<SignedRegister, Error>
pub async fn get_signed_register_from_network( &self, address: RegisterAddress, is_verifying: bool ) -> Result<SignedRegister, Error>
Get a register from network
§Arguments
- ‘address’ - RegisterAddress
- ‘is_verifying’ - Boolean: If true, we fetch at-least 2 copies from the network with more retry attempts.
Return Type:
Result<SignedRegister>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use xor_name::XorName;
use sn_registers::RegisterAddress;
// Set up a client
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Set up an address
let mut rng = rand::thread_rng();
let owner = SecretKey::random().public_key();
let xorname = XorName::random(&mut rng);
let address = RegisterAddress::new(xorname, owner);
// Get a signed register
let signed_register = client.get_signed_register_from_network(address,true);
sourcepub async fn get_register(
&self,
address: RegisterAddress
) -> Result<ClientRegister, Error>
pub async fn get_register( &self, address: RegisterAddress ) -> Result<ClientRegister, Error>
Retrieve a Register from the network.
§Arguments
- ‘address’ - RegisterAddress
Return Type:
Result<ClientRegister>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use xor_name::XorName;
use sn_registers::RegisterAddress;
// Set up a client
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Set up an address
let mut rng = rand::thread_rng();
let owner = SecretKey::random().public_key();
let xorname = XorName::random(&mut rng);
let address = RegisterAddress::new(xorname, owner);
// Get the register
let retrieved_register = client.get_register(address);
sourcepub async fn create_and_pay_for_register(
&self,
address: XorName,
wallet_client: &mut WalletClient,
verify_store: bool,
perms: Permissions
) -> Result<(ClientRegister, NanoTokens, NanoTokens), Error>
pub async fn create_and_pay_for_register( &self, address: XorName, wallet_client: &mut WalletClient, verify_store: bool, perms: Permissions ) -> Result<(ClientRegister, NanoTokens, NanoTokens), Error>
Create a new Register on the Network. Tops up payments and retries if necessary and verification failed
§Arguments
- ‘address’ - XorName
- ‘wallet_client’ - WalletClient
- ‘verify_store’ - Boolean
- ‘perms’ - Permissions
Return Type:
Result<(ClientRegister, NanoTokens, NanoTokens)>
§Example
use sn_client::{Client, WalletClient, Error};
use tempfile::TempDir;
use bls::SecretKey;
use sn_transfers::{MainSecretKey};
use xor_name::XorName;
use sn_registers::RegisterAddress;
// Set up Client, Wallet, etc
use sn_registers::Permissions;
use sn_transfers::HotWallet;
let client = Client::new(SecretKey::random(), None, None, None).await?;
let tmp_path = TempDir::new()?.path().to_owned();
let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
let mut wallet_client = WalletClient::new(client.clone(), wallet);
// Set up an address
let mut rng = rand::thread_rng();
let owner = SecretKey::random().public_key();
let xorname = XorName::random(&mut rng);
let address = RegisterAddress::new(xorname, owner);
// Example:
let (mut client_register, _storage_cost, _royalties_fees) = client
.create_and_pay_for_register(
xorname,
&mut wallet_client,
true,
Permissions::default(),
)
.await?;
sourcepub async fn get_chunk(
&self,
address: ChunkAddress,
show_holders: bool,
retry_strategy: Option<RetryStrategy>
) -> Result<Chunk, Error>
pub async fn get_chunk( &self, address: ChunkAddress, show_holders: bool, retry_strategy: Option<RetryStrategy> ) -> Result<Chunk, Error>
Get chunk from chunk address.
§Arguments
- ‘address’ - ChunkAddress
- ‘show_holders’ - Boolean
- ‘retry_strategy’ - Option<RetryStrategy> : Uses Quick by default
Return Type:
Result<Chunk>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use xor_name::XorName;
use sn_protocol::storage::ChunkAddress;
// client
let client = Client::new(SecretKey::random(), None, None, None).await?;
// chunk address
let mut rng = rand::thread_rng();
let xorname = XorName::random(&mut rng);
let chunk_address = ChunkAddress::new(xorname);
// get chunk
let chunk = client.get_chunk(chunk_address,true, None).await?;
sourcepub async fn verify_chunk_stored(&self, chunk: &Chunk) -> Result<(), Error>
pub async fn verify_chunk_stored(&self, chunk: &Chunk) -> Result<(), Error>
Verify if a Chunk
is stored by expected nodes on the network.
Single local use. Marked Private.
sourcepub async fn verify_register_stored(
&self,
address: RegisterAddress
) -> Result<SignedRegister, Error>
pub async fn verify_register_stored( &self, address: RegisterAddress ) -> Result<SignedRegister, Error>
Verify if a Register
is stored by expected nodes on the network.
§Arguments
- ‘address’ - RegisterAddress
Return Type:
Result<SignedRegister>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use xor_name::XorName;
use sn_registers::RegisterAddress;
// Set up Client
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Set up an address
let mut rng = rand::thread_rng();
let owner = SecretKey::random().public_key();
let xorname = XorName::random(&mut rng);
let address = RegisterAddress::new(xorname, owner);
// Verify address is stored
let is_stored = client.verify_register_stored(address).await.is_ok();
sourcepub async fn get_spend_from_network(
&self,
address: SpendAddress
) -> Result<SignedSpend, Error>
pub async fn get_spend_from_network( &self, address: SpendAddress ) -> Result<SignedSpend, Error>
Get a spend from network.
§Arguments
- ‘address’ - SpendAddress
Return Type:
Result<SignedSpend>
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use xor_name::XorName;
use sn_transfers::SpendAddress;
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Create a SpendAddress
let mut rng = rand::thread_rng();
let xorname = XorName::random(&mut rng);
let spend_address = SpendAddress::new(xorname);
// Here we get the spend address
let spend = client.get_spend_from_network(spend_address).await?;
// Example: We can use the spend to get its unique public key:
let unique_pubkey = spend.unique_pubkey();
sourcepub async fn verify_cash_notes_redemptions(
&self,
main_pubkey: MainPubkey,
cashnote_redemptions: &[CashNoteRedemption]
) -> Result<Vec<CashNote>, Error>
pub async fn verify_cash_notes_redemptions( &self, main_pubkey: MainPubkey, cashnote_redemptions: &[CashNoteRedemption] ) -> Result<Vec<CashNote>, Error>
This function is used to receive a Vector of CashNoteRedemptions and turn them back into spendable CashNotes.
For this we need a network connection.
Verify CashNoteRedemptions and rebuild spendable currency from them.
Returns an Error::InvalidTransfer
if any CashNoteRedemption is not valid
Else returns a list of CashNotes that can be spent by the owner.
§Arguments
- ‘main_pubkey’ - MainPubkey
- ‘cashnote_redemptions’ - CashNoteRedemption
Return Type:
§Example
use sn_client::{Client, Error};
use bls::SecretKey;
use sn_transfers::{CashNote, CashNoteRedemption, MainPubkey};
let client = Client::new(SecretKey::random(), None, None, None).await?;
// Create a main public key
let pk = SecretKey::random().public_key();
let main_pub_key = MainPubkey::new(pk);
// Create a Cash Note Redemption Vector
let cash_note = CashNote::from_hex("&hex").unwrap();
let cashNoteRedemption = CashNoteRedemption::from_cash_note(&cash_note).unwrap();
let vector = vec![cashNoteRedemption.clone(), cashNoteRedemption.clone()];
// Verify the cash note redemptions
let cash_notes = client.verify_cash_notes_redemptions(main_pub_key,&vector);
source§impl Client
impl Client
sourcepub async fn spend_dag_build_from(
&self,
spend_addr: SpendAddress,
max_depth: Option<u32>
) -> WalletResult<SpendDag>
pub async fn spend_dag_build_from( &self, spend_addr: SpendAddress, max_depth: Option<u32> ) -> WalletResult<SpendDag>
Builds a SpendDag from a given SpendAddress recursively following descendants all the way to UTxOs Started from Genesis this gives the entire SpendDag of the Network at a certain point in time Once the DAG collected, verifies and records errors in the DAG
sourcepub async fn spend_dag_extend_until(
&self,
dag: &mut SpendDag,
spend_addr: SpendAddress,
new_spend: SignedSpend
) -> WalletResult<()>
pub async fn spend_dag_extend_until( &self, dag: &mut SpendDag, spend_addr: SpendAddress, new_spend: SignedSpend ) -> WalletResult<()>
Extends an existing SpendDag with a new SignedSpend, tracing back the ancestors of that Spend all the way to a known Spend in the DAG or else back to Genesis Verifies the DAG and records faults if any This is useful to keep a partial SpendDag to be able to verify that new spends come from Genesis
... --
\
... ---- ... --
\ \
Spend0 -> Spend1 -----> Spend2 ---> Spend5 ---> Spend2 ---> Genesis
\ /
---> Spend3 ---> Spend6 ->
\ /
-> Spend4 ->
/
...
sourcepub async fn spend_dag_continue_from_utxos(
&self,
dag: &mut SpendDag,
max_depth: Option<u32>
) -> WalletResult<()>
pub async fn spend_dag_continue_from_utxos( &self, dag: &mut SpendDag, max_depth: Option<u32> ) -> WalletResult<()>
Extends an existing SpendDag starting from the utxos in this DAG Covers the entirety of currently existing Spends if the DAG was built from Genesis Records errors in the new DAG branches if any Stops gathering after max_depth generations
source§impl Client
impl Client
sourcepub async fn verify_spend_at(
&self,
addr: SpendAddress,
to_genesis: bool
) -> WalletResult<()>
pub async fn verify_spend_at( &self, addr: SpendAddress, to_genesis: bool ) -> WalletResult<()>
Verify that a spend is valid on the network. Optionally verify its ancestors as well, all the way to genesis (might take a LONG time)
Prints progress on stdout.
When verifying all the way back to genesis, it only verifies Spends that are ancestors of the given Spend, ignoring all other branches.
This is how the DAG it follows could look like:
... --
\
... ---- ... --
\ \
Spend0 -> Spend1 -----> Spend2 ---> Spend5 ---> Spend2 ---> Genesis
\ /
---> Spend3 ---> Spend6 ->
\ /
-> Spend4 ->
/
...
depth0 depth1 depth2 depth3 depth4 depth5
This function will return an error if any spend in the way is invalid.
sourcepub async fn follow_spend(
&self,
spend_addr: SpendAddress
) -> WalletResult<BTreeSet<SpendAddress>>
pub async fn follow_spend( &self, spend_addr: SpendAddress ) -> WalletResult<BTreeSet<SpendAddress>>
This function does the opposite of verify_spend. It recursively follows the descendants of a Spend, all the way to unspent Transaction Outputs (UTXOs).
Prints progress on stdout
Starting from Genesis, this amounts to Auditing the entire currency. This is how the DAG it follows could look like:
-> Spend7 ---> UTXO_11
/
Genesis -> Spend1 -----> Spend2 ---> Spend5 ---> UTXO_10
\
---> Spend3 ---> Spend6 ---> UTXO_9
\
-> Spend4 ---> UTXO_8
gen0 gen1 gen2 gen3
This function will return the UTXOs (Spend addresses not spent yet) Future calls to this function could start from those UTXOs to avoid re-checking all previously checked branches.
source§impl Client
impl Client
sourcepub async fn send_spends(
&self,
spend_requests: impl Iterator<Item = &SignedSpend>,
verify_store: bool
) -> WalletResult<()>
pub async fn send_spends( &self, spend_requests: impl Iterator<Item = &SignedSpend>, verify_store: bool ) -> WalletResult<()>
Send spend requests to the network. This can optionally verify the spends have been correctly stored before returning
§Arguments
- spend_requests - Iterator<SignedSpend>
- verify_store - Boolean. Set to true for mandatory verification via a GET request through a Spend on the network.
§Example
use sn_client::{Client, WalletClient, Error};
use bls::SecretKey;
use sn_transfers::{HotWallet, MainSecretKey};
let client = Client::new(SecretKey::random(), None, None, None).await?;
let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
// An example of sending storage payment transfers over the network with validation
client.send_spends(wallet.unconfirmed_spend_requests().iter(),true).await?;
sourcepub async fn receive(
&self,
transfer: &Transfer,
wallet: &HotWallet
) -> WalletResult<Vec<CashNote>>
pub async fn receive( &self, transfer: &Transfer, wallet: &HotWallet ) -> WalletResult<Vec<CashNote>>
Receive a Transfer, verify and redeem CashNotes from the Network.
§Arguments
§Return Value
§Example
use sn_client::{Client, WalletClient, Error};
use bls::SecretKey;
use sn_transfers::{HotWallet, MainSecretKey};
use tracing::error;
use sn_transfers::Transfer;
let client = Client::new(SecretKey::random(), None, None, None).await?;
let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
let transfer = Transfer::from_hex("13abc").unwrap();
// An example for using client.receive() for cashNotes
let cash_notes = match client.receive(&transfer, &wallet).await {
Ok(cash_notes) => cash_notes,
Err(err) => {
println!("Failed to verify and redeem transfer: {err:?}");
error!("Failed to verify and redeem transfer: {err:?}");
return Err(err.into());
}
};
sourcepub async fn verify_cashnote(&self, cash_note: &CashNote) -> WalletResult<()>
pub async fn verify_cashnote(&self, cash_note: &CashNote) -> WalletResult<()>
Verify that the spends referred to (in the CashNote) exist on the network.
§Arguments
- cash_note - CashNote
§Return value
§Example
use sn_client::{Client, WalletClient, Error};
use bls::SecretKey;
use sn_transfers::{HotWallet, MainSecretKey};
use tracing::error;
use sn_transfers::Transfer;
let client = Client::new(SecretKey::random(), None, None, None).await?;
let mut wallet = HotWallet::load_from_path(&tmp_path,Some(MainSecretKey::new(SecretKey::random())))?;
let transfer = Transfer::from_hex("").unwrap();
let cash_notes = client.receive(&transfer, &wallet).await?;
// Verification:
for cash_note in cash_notes {
println!("{:?}" , client.verify_cashnote(&cash_note).await.unwrap());
}
Trait Implementations§
Auto Trait Implementations§
impl Freeze for Client
impl !RefUnwindSafe for Client
impl Send for Client
impl Sync for Client
impl Unpin for Client
impl !UnwindSafe for Client
Blanket Implementations§
source§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
source§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> FmtForward for T
impl<T> FmtForward for T
source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<D> OwoColorize for D
impl<D> OwoColorize for D
source§fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
source§fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
source§fn black<'a>(&'a self) -> FgColorDisplay<'a, Black, Self>
fn black<'a>(&'a self) -> FgColorDisplay<'a, Black, Self>
source§fn on_black<'a>(&'a self) -> BgColorDisplay<'a, Black, Self>
fn on_black<'a>(&'a self) -> BgColorDisplay<'a, Black, Self>
source§fn red<'a>(&'a self) -> FgColorDisplay<'a, Red, Self>
fn red<'a>(&'a self) -> FgColorDisplay<'a, Red, Self>
source§fn on_red<'a>(&'a self) -> BgColorDisplay<'a, Red, Self>
fn on_red<'a>(&'a self) -> BgColorDisplay<'a, Red, Self>
source§fn green<'a>(&'a self) -> FgColorDisplay<'a, Green, Self>
fn green<'a>(&'a self) -> FgColorDisplay<'a, Green, Self>
source§fn on_green<'a>(&'a self) -> BgColorDisplay<'a, Green, Self>
fn on_green<'a>(&'a self) -> BgColorDisplay<'a, Green, Self>
source§fn yellow<'a>(&'a self) -> FgColorDisplay<'a, Yellow, Self>
fn yellow<'a>(&'a self) -> FgColorDisplay<'a, Yellow, Self>
source§fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
source§fn blue<'a>(&'a self) -> FgColorDisplay<'a, Blue, Self>
fn blue<'a>(&'a self) -> FgColorDisplay<'a, Blue, Self>
source§fn on_blue<'a>(&'a self) -> BgColorDisplay<'a, Blue, Self>
fn on_blue<'a>(&'a self) -> BgColorDisplay<'a, Blue, Self>
source§fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
source§fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
source§fn purple<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
fn purple<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
source§fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
source§fn cyan<'a>(&'a self) -> FgColorDisplay<'a, Cyan, Self>
fn cyan<'a>(&'a self) -> FgColorDisplay<'a, Cyan, Self>
source§fn on_cyan<'a>(&'a self) -> BgColorDisplay<'a, Cyan, Self>
fn on_cyan<'a>(&'a self) -> BgColorDisplay<'a, Cyan, Self>
source§fn white<'a>(&'a self) -> FgColorDisplay<'a, White, Self>
fn white<'a>(&'a self) -> FgColorDisplay<'a, White, Self>
source§fn on_white<'a>(&'a self) -> BgColorDisplay<'a, White, Self>
fn on_white<'a>(&'a self) -> BgColorDisplay<'a, White, Self>
source§fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
source§fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
source§fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
source§fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
source§fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
source§fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
source§fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
source§fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
source§fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
source§fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
source§fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
source§fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
source§fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
source§fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
source§fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
source§fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
source§fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
source§fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
source§fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
source§fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
source§fn bold<'a>(&'a self) -> BoldDisplay<'a, Self>
fn bold<'a>(&'a self) -> BoldDisplay<'a, Self>
source§fn dimmed<'a>(&'a self) -> DimDisplay<'a, Self>
fn dimmed<'a>(&'a self) -> DimDisplay<'a, Self>
source§fn italic<'a>(&'a self) -> ItalicDisplay<'a, Self>
fn italic<'a>(&'a self) -> ItalicDisplay<'a, Self>
source§fn underline<'a>(&'a self) -> UnderlineDisplay<'a, Self>
fn underline<'a>(&'a self) -> UnderlineDisplay<'a, Self>
source§fn blink<'a>(&'a self) -> BlinkDisplay<'a, Self>
fn blink<'a>(&'a self) -> BlinkDisplay<'a, Self>
source§fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
source§fn reversed<'a>(&'a self) -> ReversedDisplay<'a, Self>
fn reversed<'a>(&'a self) -> ReversedDisplay<'a, Self>
source§fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
source§fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::fg
or
a color-specific method, such as OwoColorize::green
, Read moresource§fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::bg
or
a color-specific method, such as OwoColorize::on_yellow
, Read moresource§fn fg_rgb<const R: u8, const G: u8, const B: u8>(
&self
) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>
fn fg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>
source§fn bg_rgb<const R: u8, const G: u8, const B: u8>(
&self
) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>
fn bg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>
source§fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>
fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>
source§fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>
fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>
source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moresource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read moresource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.source§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<T> Tap for T
impl<T> Tap for T
source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read moresource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read moresource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read moresource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read moresource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read moresource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read moresource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.