Struct Transaction &nbsp; Copy item path

impl<Mode> Transaction<Mode>
where Mode: TransactionMode,

async fn load_namespaces<Types>( &mut self, height: u64, payload_size: u64, ) -> QueryResult<NamespaceMap<Types>>
where Types: NodeType, Header<Types>: QueryableHeader<Types>, Payload<Types>: QueryablePayload<Types>,

impl<Mode> Transaction<Mode>
where Mode: TransactionMode,

async fn sync_status_ranges( &mut self, table: &str, indicator_column: &str, start: usize, end: usize, ) -> QueryResult<ResourceSyncStatus>

Characterize consecutive ranges of objects in the given height-indexed table by status.

This function will find all ranges in [0, block_height). If pruned_height is specified, an initial range will be created with bounds [0, pruned_height] and status SyncStatus::Pruned. Then only the range [pruned_height + 1, block_height) will actually be searched.

The search process uses an indexed outer self-join on table, which requires traversing the table twice. Thus, it can be fairly expensive on large tables, but it is still linear in the size of the table.

The value of indicator_column in the outer join results is used to check for missing objects (indicated by a NULL value). If indicator_column is a NOT NULL column, such as height, then this function will only consider objects missing if there is no corresponding row in the database at all. However, indicator_column may also be a nullable column (such as payload.data, in which case objects are treated as missing if there is no corresponding row or if there is a row but it has an explicit NULL value for indicator_column).

impl<Mode: TransactionMode> Transaction<Mode>

async fn time_window<Types: NodeType>( &mut self, start: u64, end: u64, limit: usize, ) -> QueryResult<TimeWindowQueryData<Header<Types>>>

impl<Mode: TransactionMode> Transaction<Mode>

async fn snapshot_info<Types, State, const ARITY: usize>( &mut self, snapshot: Snapshot<Types, State, ARITY>, ) -> QueryResult<(i64, State::Commit)>
where Types: NodeType, State: MerklizedState<Types, ARITY>,

Get information identifying a Snapshot.

If the given snapshot is known to the database, this function returns

The block height at which the snapshot was created
A digest of the Merkle commitment to the snapshotted state

impl<Mode> Transaction<Mode>

pub async fn load_header<Types: NodeType>( &mut self, id: impl Into<BlockId<Types>> + Send, ) -> QueryResult<Header<Types>>

Load a header from storage.

This function is similar to AvailabilityStorage::get_header, but

does not require the QueryablePayload<Types> bound that that trait impl does
makes it easier to specify types since the type parameter is on the function and not on a trait impl
allows type conversions for the id parameter

This more ergonomic interface is useful as loading headers is important for many SQL storage functions, not just the AvailabilityStorage interface.

impl<Mode: TransactionMode> Transaction<Mode>

pub(super) async fn new(pool: &Pool<Db>, metrics: PoolMetrics) -> Result<Self>

impl Transaction<Write>

Low-level, general database queries and mutation.

pub async fn upsert<'p, const N: usize, R>( &mut self, table: &str, columns: [&str; N], pk: impl IntoIterator<Item = &str>, rows: R, ) -> Result<()>
where R: IntoIterator, R::Item: 'p + FixedLengthParams<'p, N>,

impl Transaction<Write>

Query service specific mutations.

pub(super) async fn delete_batch( &mut self, state_tables: Vec<String>, height: u64, ) -> Result<()>

Delete a batch of data for pruning.

pub(crate) async fn save_pruned_height(&mut self, height: u64) -> Result<()>

Record the height of the latest pruned header.

Trait Implementations§

impl<Types, Mode: TransactionMode> AggregatesStorage<Types> for Transaction<Mode>
where Types: NodeType, Header<Types>: QueryableHeader<Types>,

async fn aggregates_height(&mut self) -> Result<usize>

The block height for which aggregate statistics are currently available.

async fn load_prev_aggregate(&mut self) -> Result<Option<Aggregate<Types>>>

the last aggregate

impl<Mode, Types> AvailabilityStorage<Types> for Transaction<Mode>
where Types: NodeType, Mode: TransactionMode, Payload<Types>: QueryablePayload<Types>, Header<Types>: QueryableHeader<Types>,

fn get_leaf<'life0, 'async_trait>( &'life0 mut self, id: LeafId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<LeafQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_block<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<BlockQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_header<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<Header<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_payload<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<PayloadQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_payload_metadata<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<PayloadMetadata<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_vid_common<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<VidCommonQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_vid_common_metadata<'life0, 'async_trait>( &'life0 mut self, id: BlockId<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<VidCommonMetadata<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn get_leaf_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<LeafQueryData<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_block_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<BlockQueryData<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_header_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<Header<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_payload_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<PayloadQueryData<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_payload_metadata_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<PayloadMetadata<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_vid_common_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<VidCommonQueryData<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_vid_common_metadata_range<'life0, 'async_trait, R>( &'life0 mut self, range: R, ) -> Pin<Box<dyn Future<Output = QueryResult<Vec<QueryResult<VidCommonMetadata<Types>>>>> + Send + 'async_trait>>
where R: RangeBounds<usize> + Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn get_block_with_transaction<'life0, 'async_trait>( &'life0 mut self, hash: TransactionHash<Types>, ) -> Pin<Box<dyn Future<Output = QueryResult<BlockQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn first_available_leaf<'life0, 'async_trait>( &'life0 mut self, from: u64, ) -> Pin<Box<dyn Future<Output = QueryResult<LeafQueryData<Types>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the first leaf which is available in the database with height >= from.

impl<Mode: Debug> Debug for Transaction<Mode>

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

Formats the value using the given formatter. Read more

impl<Mode> DerefMut for Transaction<Mode>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Mode, Types> ExplorerStorage<Types> for Transaction<Mode>
where Mode: TransactionMode, Types: NodeType, Payload<Types>: QueryablePayload<Types>, Header<Types>: QueryableHeader<Types> + ExplorerHeader<Types>, Transaction<Types>: ExplorerTransaction<Types>, BalanceAmount<Types>: Into<MonetaryValue>,

fn get_block_summaries<'life0, 'async_trait>( &'life0 mut self, request: GetBlockSummariesRequest<Types>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockSummary<Types>>, GetBlockSummariesError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_block_summaries is a method that retrieves a list of block summaries from the blockchain. The list is generated from the given GetBlockSummariesRequest.

fn get_block_detail<'life0, 'async_trait>( &'life0 mut self, request: BlockIdentifier<Types>, ) -> Pin<Box<dyn Future<Output = Result<BlockDetail<Types>, GetBlockDetailError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_block_detail is a method that retrieves the details of a specific block from the blockchain. The block is identified by the given BlockIdentifier.

fn get_transaction_summaries<'life0, 'async_trait>( &'life0 mut self, request: GetTransactionSummariesRequest<Types>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionSummary<Types>>, GetTransactionSummariesError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_transaction_summaries is a method that retrieves a list of transaction summaries from the blockchain. The list is generated from the given GetTransactionSummariesRequest.

fn get_transaction_detail<'life0, 'async_trait>( &'life0 mut self, request: TransactionIdentifier<Types>, ) -> Pin<Box<dyn Future<Output = Result<TransactionDetailResponse<Types>, GetTransactionDetailError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_transaction_detail is a method that retrieves the details of a specific transaction from the blockchain. The transaction is identified by the given TransactionIdentifier.

fn get_explorer_summary<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<ExplorerSummary<Types>, GetExplorerSummaryError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_explorer_summary is a method that retrieves a summary overview of the blockchain. This is useful for displaying information that indicates the overall status of the block chain.

fn get_search_results<'life0, 'async_trait>( &'life0 mut self, search_query: TaggedBase64, ) -> Pin<Box<dyn Future<Output = Result<SearchResult<Types>, GetSearchResultsError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

get_search_results is a method that retrieves the results of a search query against the blockchain. The results are generated from the given query string.

impl<Mode: TransactionMode> MerklizedStateHeightStorage for Transaction<Mode>

fn get_last_state_height<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = QueryResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

impl<Mode, Types, State, const ARITY: usize> MerklizedStateStorage<Types, State, ARITY> for Transaction<Mode>
where Mode: TransactionMode, Types: NodeType, State: MerklizedState<Types, ARITY> + 'static,

fn get_path<'life0, 'async_trait>( &'life0 mut self, snapshot: Snapshot<Types, State, ARITY>, key: State::Key, ) -> Pin<Box<dyn Future<Output = QueryResult<MerkleProof<State::Entry, State::Key, State::T, ARITY>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Retrieves a Merkle path from the database

impl<Mode, Types> NodeStorage<Types> for Transaction<Mode>
where Mode: TransactionMode, Types: NodeType, Header<Types>: QueryableHeader<Types>,

fn block_height<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = QueryResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn count_transactions_in_range<'life0, 'async_trait>( &'life0 mut self, range: impl 'async_trait + RangeBounds<usize> + Send, namespace: Option<NamespaceId<Types>>, ) -> Pin<Box<dyn Future<Output = QueryResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn payload_size_in_range<'life0, 'async_trait>( &'life0 mut self, range: impl 'async_trait + RangeBounds<usize> + Send, namespace: Option<NamespaceId<Types>>, ) -> Pin<Box<dyn Future<Output = QueryResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn vid_share<'life0, 'async_trait, ID>( &'life0 mut self, id: ID, ) -> Pin<Box<dyn Future<Output = QueryResult<VidShare>> + Send + 'async_trait>>
where ID: Into<BlockId<Types>> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn sync_status_for_range<'life0, 'async_trait>( &'life0 mut self, from: usize, to: usize, ) -> Pin<Box<dyn Future<Output = QueryResult<SyncStatusQueryData>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Search the given range of the database for missing objects.

fn get_header_window<'life0, 'async_trait>( &'life0 mut self, start: impl 'async_trait + Into<WindowStart<Types>> + Send + Sync, end: u64, limit: usize, ) -> Pin<Box<dyn Future<Output = QueryResult<TimeWindowQueryData<Header<Types>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn latest_qc_chain<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = QueryResult<Option<[CertificatePair<Types>; 2]>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

impl<Mode: TransactionMode> PrunedHeightStorage for Transaction<Mode>

fn load_pruned_height<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

impl<Types: NodeType> UpdateAggregatesStorage<Types> for Transaction<Write>
where Header<Types>: QueryableHeader<Types>,

async fn update_aggregates( &mut self, prev: Aggregate<Types>, blocks: &[PayloadMetadata<Types>], ) -> Result<Aggregate<Types>>

Update aggregate statistics based on a new block.

impl<Types> UpdateAvailabilityStorage<Types> for Transaction<Write>
where Types: NodeType, Payload<Types>: QueryablePayload<Types>, Header<Types>: QueryableHeader<Types>,

async fn insert_leaf_with_qc_chain( &mut self, leaf: LeafQueryData<Types>, qc_chain: Option<[CertificatePair<Types>; 2]>, ) -> Result<()>

async fn insert_block(&mut self, block: BlockQueryData<Types>) -> Result<()>

async fn insert_vid( &mut self, common: VidCommonQueryData<Types>, share: Option<VidShare>, ) -> Result<()>

fn insert_leaf( &mut self, leaf: LeafQueryData<Types>, ) -> impl Send + Future<Output = Result<()>>

impl<Types: NodeType, State: MerklizedState<Types, ARITY>, const ARITY: usize> UpdateStateData<Types, State, ARITY> for Transaction<Write>

fn set_last_state_height<'life0, 'async_trait>( &'life0 mut self, height: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn insert_merkle_nodes<'life0, 'async_trait>( &'life0 mut self, proof: MerkleProof<State::Entry, State::Key, State::T, ARITY>, traversal_path: Vec<usize>, block_number: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

fn insert_merkle_nodes_batch<'life0, 'async_trait>( &'life0 mut self, proofs: Vec<(MerkleProof<State::Entry, State::Key, State::T, ARITY>, Vec<usize>)>, block_number: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

impl<Mode> Deref for Transaction<Mode>

type Target = Transaction<'static, Postgres>

The resulting type after dereferencing.

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

Dereferences the value.

Auto Trait Implementations§

impl<Mode> Freeze for Transaction<Mode>

impl<Mode> !RefUnwindSafe for Transaction<Mode>

impl<Mode> Send for Transaction<Mode>
where Mode: Send,

impl<Mode> Sync for Transaction<Mode>
where Mode: Sync,

impl<Mode> Unpin for Transaction<Mode>
where Mode: Unpin,

impl<Mode> !UnwindSafe for Transaction<Mode>

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> ArchivePointee for T

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.

fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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<F, W, T, D> Deserialize<With<T, W>, D> for F
where W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<With<T, W>, <D as Fallible>::Error>

Deserializes using the given deserializer

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.

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

impl<T> From<T> for T

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

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

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

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

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> LayoutRaw for T

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

Gets the layout of the type.

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

fn fg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the foreground set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like red() and green(), which have the same functionality but are pithier.

§Example

Set foreground color to white using fg():

use yansi::{Paint, Color};

painted.fg(Color::White);

Set foreground color to white using white().

use yansi::Paint;

painted.white();

fn primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example

println!("{}", value.primary());

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example

println!("{}", value.fixed(color));

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example

println!("{}", value.rgb(r, g, b));

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example

println!("{}", value.black());

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example

println!("{}", value.red());

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example

println!("{}", value.green());

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example

println!("{}", value.yellow());

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example

println!("{}", value.blue());

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example

println!("{}", value.magenta());

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example

println!("{}", value.cyan());

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example

println!("{}", value.white());

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example

println!("{}", value.bright_black());

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example

println!("{}", value.bright_red());

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example

println!("{}", value.bright_green());

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example

println!("{}", value.bright_yellow());

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example

println!("{}", value.bright_blue());

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example

println!("{}", value.bright_magenta());

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example

println!("{}", value.bright_cyan());

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example

println!("{}", value.bright_white());

fn bg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the background set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like on_red() and on_green(), which have the same functionality but are pithier.

§Example

Set background color to red using fg():

use yansi::{Paint, Color};

painted.bg(Color::Red);

Set background color to red using on_red().

use yansi::Paint;

painted.on_red();

fn on_primary(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Primary].

§Example

println!("{}", value.on_primary());

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example

println!("{}", value.on_fixed(color));

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example

println!("{}", value.on_rgb(r, g, b));

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example

println!("{}", value.on_black());

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example

println!("{}", value.on_red());

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example

println!("{}", value.on_green());

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example

println!("{}", value.on_yellow());

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example

println!("{}", value.on_blue());

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example

println!("{}", value.on_magenta());

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example

println!("{}", value.on_cyan());

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example

println!("{}", value.on_white());

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example

println!("{}", value.on_bright_black());

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example

println!("{}", value.on_bright_red());

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example

println!("{}", value.on_bright_green());

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example

println!("{}", value.on_bright_yellow());

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example

println!("{}", value.on_bright_blue());

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example

println!("{}", value.on_bright_magenta());

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example

println!("{}", value.on_bright_cyan());

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example

println!("{}", value.on_bright_white());

fn attr(&self, value: Attribute) -> Painted<&T>

Enables the styling [Attribute] value.

This method should be used rarely. Instead, prefer to use attribute-specific builder methods like bold() and underline(), which have the same functionality but are pithier.

§Example

Make text bold using attr():

use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);

Make text bold using using bold().

use yansi::Paint;

painted.bold();

fn bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example

println!("{}", value.bold());

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example

println!("{}", value.dim());

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example

println!("{}", value.italic());

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example

println!("{}", value.underline());

fn blink(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Blink].

§Example

println!("{}", value.blink());

fn rapid_blink(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example

println!("{}", value.rapid_blink());

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example

println!("{}", value.invert());

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example

println!("{}", value.conceal());

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example

println!("{}", value.strike());

fn quirk(&self, value: Quirk) -> Painted<&T>

Enables the yansi [Quirk] value.

This method should be used rarely. Instead, prefer to use quirk-specific builder methods like mask() and wrap(), which have the same functionality but are pithier.

§Example

Enable wrapping using .quirk():

use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);

Enable wrapping using wrap().

use yansi::Paint;

painted.wrap();

fn mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example

println!("{}", value.mask());

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example

println!("{}", value.wrap());

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example

println!("{}", value.linger());

fn clear(&self) -> Painted<&T>

👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear(). The clear() method will be removed in a future release.

Returns self with the quirk() set to [Quirk :: Clear].

§Example

println!("{}", value.clear());

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example

println!("{}", value.resetting());

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example

println!("{}", value.bright());

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example

println!("{}", value.on_bright());

fn whenever(&self, value: Condition) -> Painted<&T>

Conditionally enable styling based on whether the [Condition] value applies. Replaces any previous condition.

See the crate level docs for more details.

§Example

Enable styling painted only when both stdout and stderr are TTYs:

use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more

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.

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Pointee for T

type Metadata = ()

The type for metadata in pointers and references to Self.

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

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)

The target type on which the method may be called.

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.

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

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.

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

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