Struct rocket::mtls::oid::asn1_rs::nom::lib::std::collections::linked_list::LinkedList
1.0.0 · source · pub struct LinkedList<T, A = Global>where
A: Allocator,{ /* private fields */ }
mtls
only.Expand description
A doubly-linked list with owned nodes.
The LinkedList
allows pushing and popping elements at either end
in constant time.
A LinkedList
with a known list of items can be initialized from an array:
use std::collections::LinkedList;
let list = LinkedList::from([1, 2, 3]);
NOTE: It is almost always better to use Vec
or VecDeque
because
array-based containers are generally faster,
more memory efficient, and make better use of CPU cache.
Implementations§
source§impl<T> LinkedList<T>
impl<T> LinkedList<T>
1.0.0 (const: 1.39.0) · sourcepub const fn new() -> LinkedList<T>
pub const fn new() -> LinkedList<T>
Creates an empty LinkedList
.
§Examples
use std::collections::LinkedList;
let list: LinkedList<u32> = LinkedList::new();
1.0.0 · sourcepub fn append(&mut self, other: &mut LinkedList<T>)
pub fn append(&mut self, other: &mut LinkedList<T>)
Moves all elements from other
to the end of the list.
This reuses all the nodes from other
and moves them into self
. After
this operation, other
becomes empty.
This operation should compute in O(1) time and O(1) memory.
§Examples
use std::collections::LinkedList;
let mut list1 = LinkedList::new();
list1.push_back('a');
let mut list2 = LinkedList::new();
list2.push_back('b');
list2.push_back('c');
list1.append(&mut list2);
let mut iter = list1.iter();
assert_eq!(iter.next(), Some(&'a'));
assert_eq!(iter.next(), Some(&'b'));
assert_eq!(iter.next(), Some(&'c'));
assert!(iter.next().is_none());
assert!(list2.is_empty());
source§impl<T, A> LinkedList<T, A>where
A: Allocator,
impl<T, A> LinkedList<T, A>where
A: Allocator,
sourcepub const fn new_in(alloc: A) -> LinkedList<T, A>
🔬This is a nightly-only experimental API. (allocator_api
)
pub const fn new_in(alloc: A) -> LinkedList<T, A>
allocator_api
)Constructs an empty LinkedList<T, A>
.
§Examples
#![feature(allocator_api)]
use std::alloc::System;
use std::collections::LinkedList;
let list: LinkedList<u32, _> = LinkedList::new_in(System);
1.0.0 · sourcepub fn iter(&self) -> Iter<'_, T> ⓘ
pub fn iter(&self) -> Iter<'_, T> ⓘ
Provides a forward iterator.
§Examples
use std::collections::LinkedList;
let mut list: LinkedList<u32> = LinkedList::new();
list.push_back(0);
list.push_back(1);
list.push_back(2);
let mut iter = list.iter();
assert_eq!(iter.next(), Some(&0));
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), None);
1.0.0 · sourcepub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
Provides a forward iterator with mutable references.
§Examples
use std::collections::LinkedList;
let mut list: LinkedList<u32> = LinkedList::new();
list.push_back(0);
list.push_back(1);
list.push_back(2);
for element in list.iter_mut() {
*element += 10;
}
let mut iter = list.iter();
assert_eq!(iter.next(), Some(&10));
assert_eq!(iter.next(), Some(&11));
assert_eq!(iter.next(), Some(&12));
assert_eq!(iter.next(), None);
sourcepub fn cursor_front(&self) -> Cursor<'_, T, A>
🔬This is a nightly-only experimental API. (linked_list_cursors
)
pub fn cursor_front(&self) -> Cursor<'_, T, A>
linked_list_cursors
)Provides a cursor at the front element.
The cursor is pointing to the “ghost” non-element if the list is empty.
sourcepub fn cursor_front_mut(&mut self) -> CursorMut<'_, T, A>
🔬This is a nightly-only experimental API. (linked_list_cursors
)
pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T, A>
linked_list_cursors
)Provides a cursor with editing operations at the front element.
The cursor is pointing to the “ghost” non-element if the list is empty.
sourcepub fn cursor_back(&self) -> Cursor<'_, T, A>
🔬This is a nightly-only experimental API. (linked_list_cursors
)
pub fn cursor_back(&self) -> Cursor<'_, T, A>
linked_list_cursors
)Provides a cursor at the back element.
The cursor is pointing to the “ghost” non-element if the list is empty.
sourcepub fn cursor_back_mut(&mut self) -> CursorMut<'_, T, A>
🔬This is a nightly-only experimental API. (linked_list_cursors
)
pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T, A>
linked_list_cursors
)Provides a cursor with editing operations at the back element.
The cursor is pointing to the “ghost” non-element if the list is empty.
1.0.0 · sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if the LinkedList
is empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert!(dl.is_empty());
dl.push_front("foo");
assert!(!dl.is_empty());
1.0.0 · sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the length of the LinkedList
.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
dl.push_front(2);
assert_eq!(dl.len(), 1);
dl.push_front(1);
assert_eq!(dl.len(), 2);
dl.push_back(3);
assert_eq!(dl.len(), 3);
1.0.0 · sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Removes all elements from the LinkedList
.
This operation should compute in O(n) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
dl.push_front(2);
dl.push_front(1);
assert_eq!(dl.len(), 2);
assert_eq!(dl.front(), Some(&1));
dl.clear();
assert_eq!(dl.len(), 0);
assert_eq!(dl.front(), None);
1.12.0 · sourcepub fn contains(&self, x: &T) -> boolwhere
T: PartialEq,
pub fn contains(&self, x: &T) -> boolwhere
T: PartialEq,
Returns true
if the LinkedList
contains an element equal to the
given value.
This operation should compute linearly in O(n) time.
§Examples
use std::collections::LinkedList;
let mut list: LinkedList<u32> = LinkedList::new();
list.push_back(0);
list.push_back(1);
list.push_back(2);
assert_eq!(list.contains(&0), true);
assert_eq!(list.contains(&10), false);
1.0.0 · sourcepub fn front(&self) -> Option<&T>
pub fn front(&self) -> Option<&T>
Provides a reference to the front element, or None
if the list is
empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.front(), None);
dl.push_front(1);
assert_eq!(dl.front(), Some(&1));
1.0.0 · sourcepub fn front_mut(&mut self) -> Option<&mut T>
pub fn front_mut(&mut self) -> Option<&mut T>
Provides a mutable reference to the front element, or None
if the list
is empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.front(), None);
dl.push_front(1);
assert_eq!(dl.front(), Some(&1));
match dl.front_mut() {
None => {},
Some(x) => *x = 5,
}
assert_eq!(dl.front(), Some(&5));
1.0.0 · sourcepub fn back(&self) -> Option<&T>
pub fn back(&self) -> Option<&T>
Provides a reference to the back element, or None
if the list is
empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.back(), None);
dl.push_back(1);
assert_eq!(dl.back(), Some(&1));
1.0.0 · sourcepub fn back_mut(&mut self) -> Option<&mut T>
pub fn back_mut(&mut self) -> Option<&mut T>
Provides a mutable reference to the back element, or None
if the list
is empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
assert_eq!(dl.back(), None);
dl.push_back(1);
assert_eq!(dl.back(), Some(&1));
match dl.back_mut() {
None => {},
Some(x) => *x = 5,
}
assert_eq!(dl.back(), Some(&5));
1.0.0 · sourcepub fn push_front(&mut self, elt: T)
pub fn push_front(&mut self, elt: T)
Adds an element first in the list.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut dl = LinkedList::new();
dl.push_front(2);
assert_eq!(dl.front().unwrap(), &2);
dl.push_front(1);
assert_eq!(dl.front().unwrap(), &1);
1.0.0 · sourcepub fn pop_front(&mut self) -> Option<T>
pub fn pop_front(&mut self) -> Option<T>
Removes the first element and returns it, or None
if the list is
empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut d = LinkedList::new();
assert_eq!(d.pop_front(), None);
d.push_front(1);
d.push_front(3);
assert_eq!(d.pop_front(), Some(3));
assert_eq!(d.pop_front(), Some(1));
assert_eq!(d.pop_front(), None);
1.0.0 · sourcepub fn push_back(&mut self, elt: T)
pub fn push_back(&mut self, elt: T)
Appends an element to the back of a list.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_back(1);
d.push_back(3);
assert_eq!(3, *d.back().unwrap());
1.0.0 · sourcepub fn pop_back(&mut self) -> Option<T>
pub fn pop_back(&mut self) -> Option<T>
Removes the last element from a list and returns it, or None
if
it is empty.
This operation should compute in O(1) time.
§Examples
use std::collections::LinkedList;
let mut d = LinkedList::new();
assert_eq!(d.pop_back(), None);
d.push_back(1);
d.push_back(3);
assert_eq!(d.pop_back(), Some(3));
1.0.0 · sourcepub fn split_off(&mut self, at: usize) -> LinkedList<T, A>where
A: Clone,
pub fn split_off(&mut self, at: usize) -> LinkedList<T, A>where
A: Clone,
Splits the list into two at the given index. Returns everything after the given index, including the index.
This operation should compute in O(n) time.
§Panics
Panics if at > len
.
§Examples
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_front(1);
d.push_front(2);
d.push_front(3);
let mut split = d.split_off(2);
assert_eq!(split.pop_front(), Some(1));
assert_eq!(split.pop_front(), None);
sourcepub fn remove(&mut self, at: usize) -> T
🔬This is a nightly-only experimental API. (linked_list_remove
)
pub fn remove(&mut self, at: usize) -> T
linked_list_remove
)Removes the element at the given index and returns it.
This operation should compute in O(n) time.
§Panics
Panics if at >= len
§Examples
#![feature(linked_list_remove)]
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_front(1);
d.push_front(2);
d.push_front(3);
assert_eq!(d.remove(1), 2);
assert_eq!(d.remove(0), 3);
assert_eq!(d.remove(0), 1);
sourcepub fn retain<F>(&mut self, f: F)
🔬This is a nightly-only experimental API. (linked_list_retain
)
pub fn retain<F>(&mut self, f: F)
linked_list_retain
)Retains only the elements specified by the predicate.
In other words, remove all elements e
for which f(&e)
returns false.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.
§Examples
#![feature(linked_list_retain)]
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_front(1);
d.push_front(2);
d.push_front(3);
d.retain(|&x| x % 2 == 0);
assert_eq!(d.pop_front(), Some(2));
assert_eq!(d.pop_front(), None);
Because the elements are visited exactly once in the original order, external state may be used to decide which elements to keep.
#![feature(linked_list_retain)]
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_front(1);
d.push_front(2);
d.push_front(3);
let keep = [false, true, false];
let mut iter = keep.iter();
d.retain(|_| *iter.next().unwrap());
assert_eq!(d.pop_front(), Some(2));
assert_eq!(d.pop_front(), None);
sourcepub fn retain_mut<F>(&mut self, f: F)
🔬This is a nightly-only experimental API. (linked_list_retain
)
pub fn retain_mut<F>(&mut self, f: F)
linked_list_retain
)Retains only the elements specified by the predicate.
In other words, remove all elements e
for which f(&e)
returns false.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.
§Examples
#![feature(linked_list_retain)]
use std::collections::LinkedList;
let mut d = LinkedList::new();
d.push_front(1);
d.push_front(2);
d.push_front(3);
d.retain_mut(|x| if *x % 2 == 0 {
*x += 1;
true
} else {
false
});
assert_eq!(d.pop_front(), Some(3));
assert_eq!(d.pop_front(), None);
sourcepub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A> ⓘ
🔬This is a nightly-only experimental API. (extract_if
)
pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A> ⓘ
extract_if
)Creates an iterator which uses a closure to determine if an element should be removed.
If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the list and will not be yielded by the iterator.
If the returned ExtractIf
is not exhausted, e.g. because it is dropped without iterating
or the iteration short-circuits, then the remaining elements will be retained.
Use extract_if().for_each(drop)
if you do not need the returned iterator.
Note that extract_if
lets you mutate every element in the filter closure, regardless of
whether you choose to keep or remove it.
§Examples
Splitting a list into evens and odds, reusing the original list:
#![feature(extract_if)]
use std::collections::LinkedList;
let mut numbers: LinkedList<u32> = LinkedList::new();
numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]);
let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<LinkedList<_>>();
let odds = numbers;
assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);
assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);
Trait Implementations§
1.0.0 · source§impl<T, A> Clone for LinkedList<T, A>
impl<T, A> Clone for LinkedList<T, A>
source§fn clone_from(&mut self, source: &LinkedList<T, A>)
fn clone_from(&mut self, source: &LinkedList<T, A>)
Overwrites the contents of self
with a clone of the contents of source
.
This method is preferred over simply assigning source.clone()
to self
,
as it avoids reallocation of the nodes of the linked list. Additionally,
if the element type T
overrides clone_from()
, this will reuse the
resources of self
’s elements as well.
source§fn clone(&self) -> LinkedList<T, A>
fn clone(&self) -> LinkedList<T, A>
1.0.0 · source§impl<T, A> Debug for LinkedList<T, A>
impl<T, A> Debug for LinkedList<T, A>
1.0.0 · source§impl<T> Default for LinkedList<T>
impl<T> Default for LinkedList<T>
source§fn default() -> LinkedList<T>
fn default() -> LinkedList<T>
Creates an empty LinkedList<T>
.
source§impl<'de, T> Deserialize<'de> for LinkedList<T>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for LinkedList<T>where
T: Deserialize<'de>,
source§fn deserialize<D>(
deserializer: D,
) -> Result<LinkedList<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<LinkedList<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
1.0.0 · source§impl<T, A> Drop for LinkedList<T, A>where
A: Allocator,
impl<T, A> Drop for LinkedList<T, A>where
A: Allocator,
1.2.0 · source§impl<'a, T, A> Extend<&'a T> for LinkedList<T, A>
impl<'a, T, A> Extend<&'a T> for LinkedList<T, A>
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = &'a T>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = &'a T>,
source§fn extend_one(&mut self, _: &'a T)
fn extend_one(&mut self, _: &'a T)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)1.0.0 · source§impl<T, A> Extend<T> for LinkedList<T, A>where
A: Allocator,
impl<T, A> Extend<T> for LinkedList<T, A>where
A: Allocator,
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = T>,
source§fn extend_one(&mut self, elem: T)
fn extend_one(&mut self, elem: T)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)1.56.0 · source§impl<T, const N: usize> From<[T; N]> for LinkedList<T>
impl<T, const N: usize> From<[T; N]> for LinkedList<T>
source§fn from(arr: [T; N]) -> LinkedList<T>
fn from(arr: [T; N]) -> LinkedList<T>
Converts a [T; N]
into a LinkedList<T>
.
use std::collections::LinkedList;
let list1 = LinkedList::from([1, 2, 3, 4]);
let list2: LinkedList<_> = [1, 2, 3, 4].into();
assert_eq!(list1, list2);
1.0.0 · source§impl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for LinkedList<T>
source§fn from_iter<I>(iter: I) -> LinkedList<T>where
I: IntoIterator<Item = T>,
fn from_iter<I>(iter: I) -> LinkedList<T>where
I: IntoIterator<Item = T>,
1.0.0 · source§impl<T, A> Hash for LinkedList<T, A>
impl<T, A> Hash for LinkedList<T, A>
1.0.0 · source§impl<'a, T, A> IntoIterator for &'a LinkedList<T, A>where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a LinkedList<T, A>where
A: Allocator,
1.0.0 · source§impl<'a, T, A> IntoIterator for &'a mut LinkedList<T, A>where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a mut LinkedList<T, A>where
A: Allocator,
1.0.0 · source§impl<T, A> IntoIterator for LinkedList<T, A>where
A: Allocator,
impl<T, A> IntoIterator for LinkedList<T, A>where
A: Allocator,
1.0.0 · source§impl<T, A> Ord for LinkedList<T, A>
impl<T, A> Ord for LinkedList<T, A>
source§fn cmp(&self, other: &LinkedList<T, A>) -> Ordering
fn cmp(&self, other: &LinkedList<T, A>) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.0.0 · source§impl<T, A> PartialEq for LinkedList<T, A>
impl<T, A> PartialEq for LinkedList<T, A>
source§fn eq(&self, other: &LinkedList<T, A>) -> bool
fn eq(&self, other: &LinkedList<T, A>) -> bool
self
and other
values to be equal, and is used by ==
.source§fn ne(&self, other: &LinkedList<T, A>) -> bool
fn ne(&self, other: &LinkedList<T, A>) -> bool
!=
. The default implementation is almost always sufficient,
and should not be overridden without very good reason.1.0.0 · source§impl<T, A> PartialOrd for LinkedList<T, A>where
T: PartialOrd,
A: Allocator,
impl<T, A> PartialOrd for LinkedList<T, A>where
T: PartialOrd,
A: Allocator,
source§impl<T> Serialize for LinkedList<T>where
T: Serialize,
impl<T> Serialize for LinkedList<T>where
T: Serialize,
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
impl<T, A> Eq for LinkedList<T, A>
impl<T, A> Send for LinkedList<T, A>
impl<T, A> Sync for LinkedList<T, A>
Auto Trait Implementations§
impl<T, A> Freeze for LinkedList<T, A>where
A: Freeze,
impl<T, A> RefUnwindSafe for LinkedList<T, A>where
A: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, A> Unpin for LinkedList<T, A>where
A: Unpin,
impl<T, A> UnwindSafe for LinkedList<T, A>
Blanket Implementations§
source§impl<'a, T> AsTaggedExplicit<'a> for Twhere
T: 'a,
impl<'a, T> AsTaggedExplicit<'a> for Twhere
T: 'a,
source§impl<'a, T> AsTaggedImplicit<'a> for Twhere
T: 'a,
impl<'a, T> AsTaggedImplicit<'a> 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> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<A, T> Collection<A> for T
impl<A, T> Collection<A> for T
source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.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> ⓘ
§impl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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 moresource§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
source§fn fg(&self, value: Color) -> Painted<&T>
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();
source§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightBlack
.
§Example
println!("{}", value.bright_black());
source§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
source§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightGreen
.
§Example
println!("{}", value.bright_green());
source§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightYellow
.
§Example
println!("{}", value.bright_yellow());
source§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
source§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightMagenta
.
§Example
println!("{}", value.bright_magenta());
source§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
source§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
Returns self
with the
fg()
set to
Color::BrightWhite
.
§Example
println!("{}", value.bright_white());
source§fn bg(&self, value: Color) -> Painted<&T>
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();
source§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
source§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
source§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlack
.
§Example
println!("{}", value.on_bright_black());
source§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
source§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightGreen
.
§Example
println!("{}", value.on_bright_green());
source§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightYellow
.
§Example
println!("{}", value.on_bright_yellow());
source§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightBlue
.
§Example
println!("{}", value.on_bright_blue());
source§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightMagenta
.
§Example
println!("{}", value.on_bright_magenta());
source§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightCyan
.
§Example
println!("{}", value.on_bright_cyan());
source§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
Returns self
with the
bg()
set to
Color::BrightWhite
.
§Example
println!("{}", value.on_bright_white());
source§fn attr(&self, value: Attribute) -> Painted<&T>
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();
source§fn underline(&self) -> Painted<&T>
fn underline(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::Underline
.
§Example
println!("{}", value.underline());
source§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
Returns self
with the
attr()
set to
Attribute::RapidBlink
.
§Example
println!("{}", value.rapid_blink());
source§fn quirk(&self, value: Quirk) -> Painted<&T>
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();
source§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.
fn clear(&self) -> Painted<&T>
resetting()
due to conflicts with Vec::clear()
.
The clear()
method will be removed in a future release.source§fn whenever(&self, value: Condition) -> Painted<&T>
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);