Struct rocket::route::Route

source ·
pub struct Route {
    pub name: Option<Cow<'static, str>>,
    pub method: Method,
    pub handler: Box<dyn Handler>,
    pub uri: RouteUri<'static>,
    pub rank: isize,
    pub format: Option<MediaType>,
    /* private fields */
}
Expand description

A request handling route.

A route consists of exactly the information in its fields. While a Route can be instantiated directly, doing so should be a rare or nonexistent event. Instead, a Rocket application should use Rocket’s #[route] series of attributes to generate a Route.

#[get("/route/<path..>?query", rank = 2, format = "json")]
fn route_name(path: PathBuf) { /* handler procedure */ }

use rocket::http::{Method, MediaType};

let route = routes![route_name].remove(0);
assert_eq!(route.name.unwrap(), "route_name");
assert_eq!(route.method, Method::Get);
assert_eq!(route.uri, "/route/<path..>?query");
assert_eq!(route.rank, 2);
assert_eq!(route.format.unwrap(), MediaType::JSON);

Note that the rank and format attribute parameters are optional. See #[route] for details on macro usage. Note also that a route’s mounted base becomes part of its URI; see RouteUri for details.

§Routing

A request is routed to a route if it has the highest precedence (lowest rank) among all routes that match the request. See Route::matches() for details on what it means for a request to match.

Note that a single request may be routed to multiple routes if a route forwards. If a route fails, the request is instead routed to the highest precedence Catcher.

§Collisions

Two routes are said to collide if there exists a request that matches both routes. Colliding routes present a routing ambiguity and are thus disallowed by Rocket. Because routes can be constructed dynamically, collision checking is done at ignite time, after it becomes statically impossible to add any more routes to an instance of Rocket.

Note that because query parsing is always lenient – extra and missing query parameters are allowed – queries do not directly impact whether two routes collide.

§Resolving Collisions

Collisions are resolved through ranking. Routes with lower ranks have higher precedence during routing than routes with higher ranks. Thus, routes are attempted in ascending rank order. If a higher precedence route returns an Outcome of Forward, the next highest precedence route is attempted, and so on, until a route returns Success or Error, or there are no more routes to try. When all routes have been attempted, Rocket issues a 404 error, handled by the appropriate Catcher.

§Default Ranking

Most collisions are automatically resolved by Rocket’s default rank. The default rank prefers static components over dynamic components in both paths and queries: the more static a route’s path and query are, the lower its rank and thus the higher its precedence.

There are three “colors” to paths and queries:

  1. static - all components are static
  2. partial - at least one, but not all, components are dynamic
  3. wild - all components are dynamic

Static paths carry more weight than static queries. The same is true for partial and wild paths. This results in the following default ranking table:

pathqueryrank
staticstatic-12
staticpartial-11
staticwild-10
staticnone-9
partialstatic-8
partialpartial-7
partialwild-6
partialnone-5
wildstatic-4
wildpartial-3
wildwild-2
wildnone-1

Recall that lower ranks have higher precedence.

§Example

use rocket::Route;
use rocket::http::Method;

macro_rules! assert_rank {
    ($($uri:expr => $rank:expr,)*) => {$(
        let route = Route::new(Method::Get, $uri, rocket::route::dummy_handler);
        assert_eq!(route.rank, $rank);
    )*}
}

assert_rank! {
    "/?foo" => -12,                 // static path, static query
    "/foo/bar?a=b&bob" => -12,      // static path, static query
    "/?a=b&bob" => -12,             // static path, static query

    "/?a&<zoo..>" => -11,           // static path, partial query
    "/foo?a&<zoo..>" => -11,        // static path, partial query
    "/?a&<zoo>" => -11,             // static path, partial query

    "/?<zoo..>" => -10,             // static path, wild query
    "/foo?<zoo..>" => -10,          // static path, wild query
    "/foo?<a>&<b>" => -10,          // static path, wild query

    "/" => -9,                      // static path, no query
    "/foo/bar" => -9,               // static path, no query

    "/a/<b>?foo" => -8,             // partial path, static query
    "/a/<b..>?foo" => -8,           // partial path, static query
    "/<a>/b?foo" => -8,             // partial path, static query

    "/a/<b>?<b>&c" => -7,           // partial path, partial query
    "/a/<b..>?a&<c..>" => -7,       // partial path, partial query

    "/a/<b>?<c..>" => -6,           // partial path, wild query
    "/a/<b..>?<c>&<d>" => -6,       // partial path, wild query
    "/a/<b..>?<c>" => -6,           // partial path, wild query

    "/a/<b>" => -5,                 // partial path, no query
    "/<a>/b" => -5,                 // partial path, no query
    "/a/<b..>" => -5,               // partial path, no query

    "/<b>/<c>?foo&bar" => -4,       // wild path, static query
    "/<a>/<b..>?foo" => -4,         // wild path, static query
    "/<b..>?cat" => -4,             // wild path, static query

    "/<b>/<c>?<foo>&bar" => -3,     // wild path, partial query
    "/<a>/<b..>?a&<b..>" => -3,     // wild path, partial query
    "/<b..>?cat&<dog>" => -3,       // wild path, partial query

    "/<b>/<c>?<foo>" => -2,         // wild path, wild query
    "/<a>/<b..>?<b..>" => -2,       // wild path, wild query
    "/<b..>?<c>&<dog>" => -2,       // wild path, wild query

    "/<b>/<c>" => -1,               // wild path, no query
    "/<a>/<b..>" => -1,             // wild path, no query
    "/<b..>" => -1,                 // wild path, no query
}

Fields§

§name: Option<Cow<'static, str>>

The name of this route, if one was given.

§method: Method

The method this route matches against.

§handler: Box<dyn Handler>

The function that should be called when the route matches.

§uri: RouteUri<'static>

The route URI.

§rank: isize

The rank of this route. Lower ranks have higher priorities.

§format: Option<MediaType>

The media type this route matches against, if any.

Implementations§

source§

impl Route

source

pub fn new<H: Handler>(method: Method, uri: &str, handler: H) -> Route

Creates a new route with the given method, path, and handler with a base of / and a computed default rank.

§Panics

Panics if path is not a valid Rocket route URI.

A valid route URI is any valid Origin URI that is normalized, that is, does not contain any empty segments except for an optional trailing slash. Unlike a strict Origin, route URIs are also allowed to contain any UTF-8 characters.

§Example
use rocket::Route;
use rocket::http::Method;

// this is a route matching requests to `GET /`
let index = Route::new(Method::Get, "/", handler);
assert_eq!(index.rank, -9);
assert_eq!(index.method, Method::Get);
assert_eq!(index.uri, "/");
source

pub fn ranked<H, R>(rank: R, method: Method, uri: &str, handler: H) -> Route
where H: Handler + 'static, R: Into<Option<isize>>,

Creates a new route with the given rank, method, path, and handler with a base of /. If rank is None, the computed default rank is used.

§Panics

Panics if path is not a valid Rocket route URI.

A valid route URI is any valid Origin URI that is normalized, that is, does not contain any empty segments except for an optional trailing slash. Unlike a strict Origin, route URIs are also allowed to contain any UTF-8 characters.

§Example
use rocket::Route;
use rocket::http::Method;

let foo = Route::ranked(1, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, 1);
assert_eq!(foo.method, Method::Post);
assert_eq!(foo.uri, "/foo?bar");

let foo = Route::ranked(None, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, -12);
assert_eq!(foo.method, Method::Post);
assert_eq!(foo.uri, "/foo?bar");
source

pub fn rebase(self, base: Origin<'_>) -> Self

Prefix base to any existing mount point base in self.

If the the current mount point base is /, then the base is replaced by base. Otherwise, base is prefixed to the existing base.

use rocket::Route;
use rocket::http::Method;

// The default base is `/`.
let index = Route::new(Method::Get, "/foo/bar", handler);

// Since the base is `/`, rebasing replaces the base.
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");

// Now every rebase prefixes.
let rebased = rebased.rebase(uri!("/base"));
assert_eq!(rebased.uri.base(), "/base/boo");

// Rebasing to `/` does nothing.
let rebased = rebased.rebase(uri!("/"));
assert_eq!(rebased.uri.base(), "/base/boo");

// Note that trailing slashes are preserved:
let index = Route::new(Method::Get, "/foo", handler);
let rebased = index.rebase(uri!("/boo/"));
assert_eq!(rebased.uri.base(), "/boo/");
source

pub fn map_base<'a, F>(self, mapper: F) -> Result<Self, Error<'static>>
where F: FnOnce(Origin<'a>) -> String,

Maps the base of this route using mapper, returning a new Route with the returned base.

Note: Prefer to use Route::rebase() whenever possible!

mapper is called with the current base. The returned String is used as the new base if it is a valid URI. If the returned base URI contains a query, it is ignored. Returns an error if the base produced by mapper is not a valid origin URI.

§Example
use rocket::Route;
use rocket::http::Method;

let index = Route::new(Method::Get, "/foo/bar", handler);
assert_eq!(index.uri.base(), "/");
assert_eq!(index.uri.unmounted().path(), "/foo/bar");
assert_eq!(index.uri.path(), "/foo/bar");

let mapped = index.map_base(|base| format!("{}{}", "/boo", base)).unwrap();
assert_eq!(mapped.uri.base(), "/boo/");
assert_eq!(mapped.uri.unmounted().path(), "/foo/bar");
assert_eq!(mapped.uri.path(), "/boo/foo/bar");

// Note that this produces different `base` results than `rebase`!
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");
assert_eq!(rebased.uri.unmounted().path(), "/foo/bar");
assert_eq!(rebased.uri.path(), "/boo/foo/bar");
source§

impl Route

source

pub fn collides_with(&self, other: &Route) -> bool

Returns true if self collides with other.

A collision between two routes occurs when there exists a request that could match either route. That is, a routing ambiguity would ensue if both routes were made available to the router.

Specifically, a collision occurs when two routes a and b:

  • Have the same method.
  • Have the same rank.
  • The routes’ methods don’t support a payload or the routes’ methods support a payload and the formats overlap. Formats overlap when:
    • The top-level type of either is * or the top-level types are equivalent.
    • The sub-level type of either is * or the sub-level types are equivalent.
  • Have overlapping route URIs. This means that either:
    • The URIs have the same number of segments n, and for i in 0..n, either a.uri[i] is dynamic or b.uri[i] is dynamic or they’re both static with the same value.
    • One URI has fewer segments and ends with a trailing dynamic parameter and the preceding segments in both routes match the conditions above.

Collisions are symmetric: for any routes a and b, a.collides_with(b) => b.collides_with(a).

§Example
use rocket::Route;
use rocket::http::{Method, MediaType};

// Two routes with the same method, rank, URI, and formats collide.
let a = Route::new(Method::Get, "/", handler);
let b = Route::new(Method::Get, "/", handler);
assert!(a.collides_with(&b));

// Two routes with the same method, rank, URI, and overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::new("*", "custom"));
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::new("text", "*"));
assert!(a.collides_with(&b));

// Two routes with different ranks don't collide.
let a = Route::ranked(1, Method::Get, "/", handler);
let b = Route::ranked(2, Method::Get, "/", handler);
assert!(!a.collides_with(&b));

// Two routes with different methods don't collide.
let a = Route::new(Method::Put, "/", handler);
let b = Route::new(Method::Post, "/", handler);
assert!(!a.collides_with(&b));

// Two routes with non-overlapping URIs do not collide.
let a = Route::new(Method::Get, "/foo", handler);
let b = Route::new(Method::Get, "/bar/<baz>", handler);
assert!(!a.collides_with(&b));

// Two payload-supporting routes with non-overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::JSON);
assert!(!a.collides_with(&b));

// Two non payload-supporting routes with non-overlapping formats
// collide. A request with `Accept: */*` matches both.
let mut a = Route::new(Method::Get, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Get, "/", handler);
b.format = Some(MediaType::JSON);
assert!(a.collides_with(&b));
source§

impl Route

source

pub fn matches(&self, request: &Request<'_>) -> bool

Returns true if self matches request.

A match occurs when:

  • The route’s method matches that of the incoming request.
  • Either the route has no format or:
    • If the route’s method supports a payload, the request’s Content-Type is fully specified and collides with the route’s format.
    • If the route’s method does not support a payload, the request either has no Accept header or it collides with with the route’s format.
  • All static segments in the route’s URI match the corresponding components in the same position in the incoming request URI.
  • The route URI has no query part or all static segments in the route’s query string are in the request query string, though in any position.

For a request to be routed to a particular route, that route must both match and have the highest precedence among all matching routes for that request. In other words, a match is a necessary but insufficient condition to determine if a route will handle a particular request.

The precedence of a route is determined by its rank. Routes with lower ranks have higher precedence. By default, more specific routes are assigned a lower ranking.

§Example
use rocket::Route;
use rocket::http::Method;

// This route handles GET requests to `/<hello>`.
let a = Route::new(Method::Get, "/<hello>", handler);

// This route handles GET requests to `/здрасти`.
let b = Route::new(Method::Get, "/здрасти", handler);

// Let's say `request` is `GET /hello`. The request matches only `a`:
let request = client.get("/hello");
assert!(a.matches(&request));
assert!(!b.matches(&request));

// Now `request` is `GET /здрасти`. It matches both `a` and `b`:
let request = client.get("/здрасти");
assert!(a.matches(&request));
assert!(b.matches(&request));

// But `b` is more specific, so it has lower rank (higher precedence)
// by default, so Rocket would route the request to `b`, not `a`.
assert!(b.rank < a.rank);

Trait Implementations§

source§

impl Clone for Route

source§

fn clone(&self) -> Route

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Route

source§

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

Formats the value using the given formatter. Read more
source§

impl Display for Route

source§

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

Formats the value using the given formatter. Read more
source§

impl<'r> FromRequest<'r> for &'r Route

§

type Error = Infallible

The associated error to be returned if derivation fails.
source§

fn from_request<'life0, 'async_trait>( request: &'r Request<'life0> ) -> Pin<Box<dyn Future<Output = Outcome<Self, Infallible>> + Send + 'async_trait>>
where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Derives an instance of Self from the incoming request metadata. Read more

Auto Trait Implementations§

§

impl !Freeze for Route

§

impl !RefUnwindSafe for Route

§

impl Send for Route

§

impl Sync for Route

§

impl Unpin for Route

§

impl !UnwindSafe for Route

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

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

source§

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 primary(&self) -> Painted<&T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

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

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

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>

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

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

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

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

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

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>

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

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

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>

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

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

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

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>

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

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

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>

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

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

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>

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

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

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 bold(&self) -> Painted<&T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 mask(&self) -> Painted<&T>

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

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

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

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

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

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

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

§Example
println!("{}", value.linger());
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.

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

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

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

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

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

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

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

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

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

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

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

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

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

Create a new Painted with a default Style. Read more
source§

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

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T, U> Upcast<T> for U
where T: UpcastFrom<U>,

source§

fn upcast(self) -> T

source§

impl<T, B> UpcastFrom<Counter<T, B>> for T

source§

fn upcast_from(value: Counter<T, B>) -> T

source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

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

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> EndpointAddr for T
where T: Display + Debug + Sync + Send + Any,