pub struct Query<'a> { /* private fields */ }
Expand description
A URI query: ?foo&bar
.
Implementations§
source§impl<'a> Query<'a>
impl<'a> Query<'a>
sourcepub fn raw(&self) -> &'a RawStr
pub fn raw(&self) -> &'a RawStr
Returns the raw, undecoded query value.
Example
let uri = uri!("/foo?baz+bar");
assert_eq!(uri.query().unwrap(), "baz+bar");
assert_eq!(uri.query().unwrap().raw(), "baz+bar");
sourcepub fn as_str(&self) -> &'a str
pub fn as_str(&self) -> &'a str
Returns the raw, undecoded query value as an &str
.
Example
let uri = uri!("/foo/bar?baz+bar");
assert_eq!(uri.query().unwrap(), "baz+bar");
assert_eq!(uri.query().unwrap().as_str(), "baz+bar");
sourcepub fn raw_segments(&self) -> impl Iterator<Item = &'a RawStr>
pub fn raw_segments(&self) -> impl Iterator<Item = &'a RawStr>
Returns an iterator over the undecoded, potentially empty (name, value)
pairs of this query. If there is no query, the iterator is
empty.
Example
use rocket::http::uri::Origin;
let uri = Origin::parse("/").unwrap();
assert!(uri.query().is_none());
let uri = Origin::parse("/?").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert!(query_segs.is_empty());
let uri = Origin::parse("/?foo").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert_eq!(query_segs, &["foo"]);
let uri = Origin::parse("/?a=b&dog").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert_eq!(query_segs, &["a=b", "dog"]);
let uri = Origin::parse("/?&").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert_eq!(query_segs, &["", ""]);
// Recall that `uri!()` normalizes, so this is equivalent to `/?`.
let uri = uri!("/?&");
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert!(query_segs.is_empty());
// These are raw and undecoded. Use `segments()` for decoded variant.
let uri = Origin::parse("/foo/bar?a+b%2F=some+one%40gmail.com&&%26%3D2").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().raw_segments().collect();
assert_eq!(query_segs, &["a+b%2F=some+one%40gmail.com", "", "%26%3D2"]);
sourcepub fn segments(&self) -> Segments<'a, Query> ⓘ
pub fn segments(&self) -> Segments<'a, Query> ⓘ
Returns a (smart) iterator over the non-empty, url-decoded (name, value)
pairs of this query. If there is no query, the iterator is
empty.
Example
use rocket::http::uri::Origin;
let uri = Origin::parse("/").unwrap();
assert!(uri.query().is_none());
let uri = Origin::parse("/foo/bar?a+b%2F=some+one%40gmail.com&&%26%3D2").unwrap();
let query_segs: Vec<_> = uri.query().unwrap().segments().collect();
assert_eq!(query_segs, &[("a b/", "some one@gmail.com"), ("&=2", "")]);
Methods from Deref<Target = RawStr>§
sourcepub fn percent_decode(&self) -> Result<Cow<'_, str>, Utf8Error>
pub fn percent_decode(&self) -> Result<Cow<'_, str>, Utf8Error>
Returns a percent-decoded version of the string.
Errors
Returns an Err
if the percent encoded values are not valid UTF-8.
Example
With a valid string:
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode();
assert_eq!(decoded, Ok("Hello!".into()));
With an invalid string:
use rocket::http::RawStr;
let bad_raw_str = RawStr::new("%FF");
assert!(bad_raw_str.percent_decode().is_err());
sourcepub fn percent_decode_lossy(&self) -> Cow<'_, str>
pub fn percent_decode_lossy(&self) -> Cow<'_, str>
Returns a percent-decoded version of the string. Any invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.
Example
With a valid string:
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode_lossy();
assert_eq!(decoded, "Hello!");
With an invalid string:
use rocket::http::RawStr;
let bad_raw_str = RawStr::new("a=%FF");
assert_eq!(bad_raw_str.percent_decode_lossy(), "a=�");
sourcepub fn percent_encode(&self) -> Cow<'_, RawStr>
pub fn percent_encode(&self) -> Cow<'_, RawStr>
Returns a percent-encoded version of the string.
Example
With a valid string:
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode();
assert_eq!(decoded, Ok("Hello!".into()));
With an invalid string:
use rocket::http::RawStr;
let bad_raw_str = RawStr::new("%FF");
assert!(bad_raw_str.percent_decode().is_err());
sourcepub fn url_decode(&self) -> Result<Cow<'_, str>, Utf8Error>
pub fn url_decode(&self) -> Result<Cow<'_, str>, Utf8Error>
Returns a URL-decoded version of the string. This is identical to
percent decoding except that +
characters are converted into spaces.
This is the encoding used by form values.
Errors
Returns an Err
if the percent encoded values are not valid UTF-8.
Example
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello%2C+world%21");
let decoded = raw_str.url_decode();
assert_eq!(decoded.unwrap(), "Hello, world!");
sourcepub fn url_decode_lossy(&self) -> Cow<'_, str>
pub fn url_decode_lossy(&self) -> Cow<'_, str>
Returns a URL-decoded version of the string.
Any invalid UTF-8 percent-encoded byte sequences will be replaced �
U+FFFD, the replacement character. This is identical to lossy percent
decoding except that +
characters are converted into spaces. This is
the encoding used by form values.
Example
With a valid string:
use rocket::http::RawStr;
let raw_str: &RawStr = "Hello%2C+world%21".into();
let decoded = raw_str.url_decode_lossy();
assert_eq!(decoded, "Hello, world!");
With an invalid string:
use rocket::http::RawStr;
let bad_raw_str = RawStr::new("a+b=%FF");
assert_eq!(bad_raw_str.url_decode_lossy(), "a b=�");
sourcepub fn html_escape(&self) -> Cow<'_, str>
pub fn html_escape(&self) -> Cow<'_, str>
Returns an HTML escaped version of self
. Allocates only when
characters need to be escaped.
The following characters are escaped: &
, <
, >
, "
, '
, /
,
`
. This suffices as long as the escaped string is not
used in an execution context such as inside of <script> or <style>
tags! See the OWASP XSS Prevention Rules for more information.
Example
Strings with HTML sequences are escaped:
use rocket::http::RawStr;
let raw_str: &RawStr = "<b>Hi!</b>".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "<b>Hi!</b>");
let raw_str: &RawStr = "Hello, <i>world!</i>".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "Hello, <i>world!</i>");
Strings without HTML sequences remain untouched:
use rocket::http::RawStr;
let raw_str: &RawStr = "Hello!".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "Hello!");
let raw_str: &RawStr = "大阪".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "大阪");
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if self
has a length of zero bytes.
Example
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello, world!");
assert!(!raw_str.is_empty());
let raw_str = RawStr::new("");
assert!(raw_str.is_empty());
sourcepub fn as_str(&self) -> &str
pub fn as_str(&self) -> &str
Converts self
into an &str
.
This method should be used sparingly. Only use this method when you are absolutely certain that doing so is safe.
Example
use rocket::http::RawStr;
let raw_str = RawStr::new("Hello, world!");
assert_eq!(raw_str.as_str(), "Hello, world!");
sourcepub fn as_bytes(&self) -> &[u8] ⓘ
pub fn as_bytes(&self) -> &[u8] ⓘ
Converts self
into an &[u8]
.
Example
use rocket::http::RawStr;
let raw_str = RawStr::new("hi");
assert_eq!(raw_str.as_bytes(), &[0x68, 0x69]);
sourcepub fn as_ptr(&self) -> *const u8
pub fn as_ptr(&self) -> *const u8
Converts a string slice to a raw pointer.
As string slices are a slice of bytes, the raw pointer points to a
u8
. This pointer will be pointing to the first byte of the string
slice.
The caller must ensure that the returned pointer is never written to.
If you need to mutate the contents of the string slice, use as_mut_ptr
.
Examples
Basic usage:
use rocket::http::RawStr;
let raw_str = RawStr::new("hi");
let ptr = raw_str.as_ptr();
sourcepub fn as_uncased_str(&self) -> &UncasedStr
pub fn as_uncased_str(&self) -> &UncasedStr
Converts self
into an &UncasedStr
.
This method should be used sparingly. Only use this method when you are absolutely certain that doing so is safe.
Example
use rocket::http::RawStr;
let raw_str = RawStr::new("Content-Type");
assert!(raw_str.as_uncased_str() == "content-TYPE");
sourcepub fn contains<'a, P>(&'a self, pat: P) -> boolwhere
P: Pattern<'a>,
pub fn contains<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>,
Returns true
if the given pattern matches a sub-slice of
this string slice.
Returns false
if it does not.
The pattern can be a &str
, char
, a slice of char
s, or a
function or closure that determines if a character matches.
Examples
Basic usage:
use rocket::http::RawStr;
let bananas = RawStr::new("bananas");
assert!(bananas.contains("nana"));
assert!(!bananas.contains("apples"));
sourcepub fn starts_with<'a, P>(&'a self, pat: P) -> boolwhere
P: Pattern<'a>,
pub fn starts_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>,
Returns true
if the given pattern matches a prefix of this
string slice.
Returns false
if it does not.
The pattern can be a &str
, char
, a slice of char
s, or a
function or closure that determines if a character matches.
Examples
Basic usage:
use rocket::http::RawStr;
let bananas = RawStr::new("bananas");
assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
sourcepub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
Returns true
if the given pattern matches a suffix of this
string slice.
Returns false
if it does not.
The pattern can be a &str
, char
, a slice of char
s, or a
function or closure that determines if a character matches.
Examples
Basic usage:
use rocket::http::RawStr;
let bananas = RawStr::new("bananas");
assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));
sourcepub fn find<'a, P>(&'a self, pat: P) -> Option<usize>where
P: Pattern<'a>,
pub fn find<'a, P>(&'a self, pat: P) -> Option<usize>where P: Pattern<'a>,
Returns the byte index of the first character of this string slice that matches the pattern.
Returns None
if the pattern doesn’t match.
The pattern can be a &str
, char
, a slice of char
s, or a
function or closure that determines if a character matches.
Example
use rocket::http::RawStr;
let s = RawStr::new("Löwe 老虎 Léopard Gepardi");
assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("pard"), Some(17));
sourcepub fn split<'a, P>(&'a self, pat: P) -> impl DoubleEndedIteratorwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
pub fn split<'a, P>(&'a self, pat: P) -> impl DoubleEndedIteratorwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
An iterator over substrings of this string slice, separated by characters matched by a pattern.
The pattern can be a &str
, char
, a slice of char
s, or a
function or closure that determines if a character matches.
Examples
Simple patterns:
use rocket::http::RawStr;
let v: Vec<_> = RawStr::new("Mary had a little lamb")
.split(' ')
.map(|r| r.as_str())
.collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
sourcepub fn split_at_byte(&self, b: u8) -> (&RawStr, &RawStr)
pub fn split_at_byte(&self, b: u8) -> (&RawStr, &RawStr)
Splits self
into two pieces: the piece before the first byte b
and
the piece after (not including b
). Returns the tuple (before
,
after
). If b
is not in self
, or b
is not an ASCII characters,
returns the entire string self
as before
and the empty string as
after
.
Example
use rocket::http::RawStr;
let haystack = RawStr::new("a good boy!");
let (before, after) = haystack.split_at_byte(b'a');
assert_eq!(before, "");
assert_eq!(after, " good boy!");
let (before, after) = haystack.split_at_byte(b' ');
assert_eq!(before, "a");
assert_eq!(after, "good boy!");
let (before, after) = haystack.split_at_byte(b'o');
assert_eq!(before, "a g");
assert_eq!(after, "od boy!");
let (before, after) = haystack.split_at_byte(b'!');
assert_eq!(before, "a good boy");
assert_eq!(after, "");
let (before, after) = haystack.split_at_byte(b'?');
assert_eq!(before, "a good boy!");
assert_eq!(after, "");
let haystack = RawStr::new("");
let (before, after) = haystack.split_at_byte(b' ');
assert_eq!(before, "");
assert_eq!(after, "");
sourcepub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a RawStr>where
P: Pattern<'a>,
pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a RawStr>where P: Pattern<'a>,
Returns a string slice with the prefix removed.
If the string starts with the pattern prefix
, returns substring after
the prefix, wrapped in Some
. This method removes the prefix exactly
once.
If the string does not start with prefix
, returns None
.
The pattern can be a &str
, char
, a slice of char
s, or a function
or closure that determines if a character matches.
Examples
use rocket::http::RawStr;
assert_eq!(RawStr::new("foo:bar").strip_prefix("foo:").unwrap(), "bar");
assert_eq!(RawStr::new("foofoo").strip_prefix("foo").unwrap(), "foo");
assert!(RawStr::new("foo:bar").strip_prefix("bar").is_none());
sourcepub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a RawStr>where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a RawStr>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
Returns a string slice with the suffix removed.
If the string ends with the pattern suffix
, returns the substring
before the suffix, wrapped in Some
. Unlike trim_end_matches
, this
method removes the suffix exactly once.
If the string does not end with suffix
, returns None
.
The pattern can be a &str
, char
, a slice of char
s, or a function
or closure that determines if a character matches.
Examples
use rocket::http::RawStr;
assert_eq!(RawStr::new("bar:foo").strip_suffix(":foo").unwrap(), "bar");
assert_eq!(RawStr::new("foofoo").strip_suffix("foo").unwrap(), "foo");
assert!(RawStr::new("bar:foo").strip_suffix("bar").is_none());
sourcepub fn trim(&self) -> &RawStr
pub fn trim(&self) -> &RawStr
Returns a string slice with leading and trailing whitespace removed.
‘Whitespace’ is defined according to the terms of the Unicode Derived
Core Property White_Space
, which includes newlines.
Examples
Basic usage:
use rocket::http::RawStr;
let s = RawStr::new("\n Hello\tworld\t\n");
assert_eq!("Hello\tworld", s.trim());
sourcepub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>where
F: FromStr,
pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>where F: FromStr,
Parses this string slice into another type.
Because parse
is so general, it can cause problems with type
inference. As such, parse
is one of the few times you’ll see
the syntax affectionately known as the ‘turbofish’: ::<>
. This
helps the inference algorithm understand specifically which type
you’re trying to parse into.
Errors
Will return Err
if it’s not possible to parse this string slice into
the desired type.
Examples
Basic usage
use rocket::http::RawStr;
let four: u32 = RawStr::new("4").parse().unwrap();
assert_eq!(4, four);
Trait Implementations§
source§impl PartialEq<&RawStr> for Query<'_>
impl PartialEq<&RawStr> for Query<'_>
source§impl PartialEq<&str> for Query<'_>
impl PartialEq<&str> for Query<'_>
source§impl PartialEq<Query<'_>> for &RawStr
impl PartialEq<Query<'_>> for &RawStr
source§impl PartialEq<Query<'_>> for &str
impl PartialEq<Query<'_>> for &str
source§impl PartialEq<Query<'_>> for Query<'_>
impl PartialEq<Query<'_>> for Query<'_>
source§impl PartialEq<Query<'_>> for RawStr
impl PartialEq<Query<'_>> for RawStr
source§impl PartialEq<Query<'_>> for str
impl PartialEq<Query<'_>> for str
source§impl PartialEq<RawStr> for Query<'_>
impl PartialEq<RawStr> for Query<'_>
impl<'a> Copy for Query<'a>
impl Eq for Query<'_>
Auto Trait Implementations§
impl<'a> !RefUnwindSafe for Query<'a>
impl<'a> Send for Query<'a>
impl<'a> Sync for Query<'a>
impl<'a> Unpin for Query<'a>
impl<'a> !UnwindSafe for Query<'a>
Blanket Implementations§
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<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
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>
source§impl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
source§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>
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>
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>
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 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);