Struct libpt_cli::args::VerbosityLevel

pub struct VerbosityLevel { /* private fields */ }

Transform -v and -q flags to some kind of loglevel

Example

Include this into your clap derive struct like this:

use libpt_cli::args::VerbosityLevel;
use clap::Parser;

#[derive(Parser, Debug)]
pub struct Opts {
    #[command(flatten)]
    pub verbose: VerbosityLevel,
    #[arg(short, long)]
    pub mynum: usize,
}

Get the loglevel like this:

use libpt_log::Level;


fn main() {
    let opts = Opts::parse();

    // Level might be None if the user wants no output at all.
    // for the 'tracing' level:
    let level: Level = opts.verbose.level();
}

Implementations

impl VerbosityLevel

pub fn changed(&self) -> bool

true only if no verbose and no quiet was set (user is using defaults)

pub fn level(&self) -> Level

get the Level for that VerbosityLevel

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::INFO;
assert_eq!(verbosity_level.level(), Level::INFO);

Examples found in repository

examples/cli.rs (line 27)

fn main() {
    let cli = Cli::parse();
    let _logger = Logger::builder()
        .max_level(cli.verbosity.level())
        .show_time(false)
        .build();

    debug!("logger initialized with level: {}", cli.verbosity.level());

    if !cli.machine {
        let text = cli.text.join(" ");
        printing::blockprint(text, console::Color::Green);
    } else {
        for text in cli.text {
            println!("{text}")
        }
    }
}

pub const TRACE: Self = _

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::TRACE;
assert_eq!(verbosity_level.level(), Level::TRACE);

pub const DEBUG: Self = _

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::DEBUG;
assert_eq!(verbosity_level.level(), Level::DEBUG);

pub const INFO: Self = _

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::INFO;
assert_eq!(verbosity_level.level(), Level::INFO);

pub const WARN: Self = _

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::WARN;
assert_eq!(verbosity_level.level(), Level::WARN);

pub const ERROR: Self = _

Examples

use libpt_log::Level; // reexport: tracing
use libpt_cli::args::VerbosityLevel;

let verbosity_level = VerbosityLevel::ERROR;
assert_eq!(verbosity_level.level(), Level::ERROR);

Trait Implementations

impl Args for VerbosityLevel

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self.

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can update self.

impl Clone for VerbosityLevel

fn clone(&self) -> VerbosityLevel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommandFactory for VerbosityLevel

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for VerbosityLevel

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

Formats the value using the given formatter.

impl Default for VerbosityLevel

fn default() -> Self

Returns the “default value” for a type.

impl FromArgMatches for VerbosityLevel

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Hash for VerbosityLevel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parser for VerbosityLevel

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl PartialEq for VerbosityLevel

fn eq(&self, other: &VerbosityLevel) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for VerbosityLevel

impl StructuralPartialEq for VerbosityLevel