Struct BaseArgs

pub struct BaseArgs {

    pub bytes: bool,
    pub no_pad: bool,
    pub prefix: String,
    pub separator: String,
    pub lowercase: bool,
    pub filter_chars: bool,
    pub collapse_filtered: bool,
    pub collapse_only: Vec<String>,
    pub parse_prefixes: bool,
    pub limit: u64,
    pub pad: bool,
    pub pad_l: u32,
    pub quiet: bool,
}

Fields

bytes: bool

Shortcut for -n -q –limit 255 –pad

no_pad: bool

Invalid unless using –bytes option. Turns off padding.

prefix: String

Add prefix to each output number (e.g. 0x)

separator: String

Separator inserted after numeric output values (except the last one).

An empty separator is not quite equivalent to not having had a separator at all during the conversion — it concatenates their string representations, which can produce different numeric results depending on leading zeros.

Examples:

• Hex bytes [0x1A, 0x08] with a separator -> “1A 08”.
• Concatenating without a separator -> “1A08”, which is still two numbers (decimal 26 and 8), not a single number 0x1A08 = 6664 decimal.
  • Consider that normalizing the input numbers first by removing their leading zeroes would yield a different number, 0x1A8 (decimal 424).

lowercase: bool

Output numbers in base 11+ using lowercase letters, rather than the default of uppercase. Does not change the case of input characters that are not parts of numbers.

filter_chars: bool

Whether to filter out bytes that aren’t digits in the input base.

collapse_filtered: bool

Should filtered characters be totally ignored for parsing numbers? E.g. 10_000 would get the _ filtered out and be treated as 10000.

collapse_only: Vec<String>

A list of filtered characters to collapse, leaving others as spaces.

parse_prefixes: bool

Whether to interpret existing prefixes (e.g. 0x) in the input. If set to false, it may produce silly results in some cases, like when converting hex with 0x prefixes to another base. If you also ask it to add prefixes, you’ll get three prefixes for each number! (Because it will take 0 as a number, then pass through x, then take the actual number.)

limit: u64

Limit width for each number. Input numbers will be split up if longer than this value (0x0404 would be read as 0x04 04). The value of this argument should be the maximum value that you need to represent, and the width in bytes will be derived from that dependent on the base. Set to 0 to disable limiting.

pad: bool

Zero-pad the left of each number to the number of digits determined by the limit argument. Requires a limit to be set.

pad_l: u32

Zero-pad the left of each number to at least this many digits. Set to 0 or 1 to turn off.

quiet: bool

Suppress warning messages

Trait Implementations

impl Args for BaseArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

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

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

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

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Debug for BaseArgs

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

Formats the value using the given formatter.

impl FromArgMatches for BaseArgs

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.