Struct FmtArg 

pub struct FmtArg {
    pub indentation: u8,
    pub is_alternate: bool,
    pub fmt_kind: FmtKind,
    pub number_fmt: NumberFmt,
}

Carries all of the configuration for formatting functions.

Example

use const_panic::{ArrayString, FmtArg, StdWrapper};

// `StdWrapper` wraps references to std types to provide their `to_panicvals` methods
const ARRAY: &[&str] = &["3", "foo\nbar", "\0qux"];

// Debug formatting
assert_eq!(
    const_panic::concat_!(FmtArg::DEBUG; ARRAY),
    r#"["3", "foo\nbar", "\x00qux"]"#
);

// Alternate-Debug formatting
assert_eq!(
    const_panic::concat_!(FmtArg::ALT_DEBUG; ARRAY),
    concat!(
        "[\n",
        "    \"3\",\n",
        "    \"foo\\nbar\",\n",
        "    \"\\x00qux\",\n",
        "]",
    )
);

// Display formatting
assert_eq!(
    const_panic::concat_!(FmtArg::DISPLAY; ARRAY),
    "[3, foo\nbar, \x00qux]"
);

// Alternate-Display formatting
assert_eq!(
    const_panic::concat_!(FmtArg::ALT_DISPLAY; ARRAY),
    concat!(
        "[\n",
        "    3,\n",
        "    foo\n",
        "bar,\n",
        "    \x00qux,\n",
        "]",
    )
);

Fields

indentation: u8

How much indentation is needed for a field/array element.

Indentation is used by fmt::Delimiter and by fmt::Separator, when the is_alternate field flag is enabled.

is_alternate: bool

Whether alternate formatting is being used.

fmt_kind: FmtKind

Whether this is intended to be Display or Debug formatted.

number_fmt: NumberFmt

What integers are formatted as: decimal, hexadecimal, or binary.

Implementations

impl FmtArg

pub const fn pack(self) -> PackedFmtArg

Converts this FmtArg into a PackedFmtArg, which is smaller but can only be converted back into a FmtArg.

impl FmtArg

pub const DISPLAY: Self

A FmtArg with no indentation and Display formatting.

pub const ALT_DISPLAY: Self

A FmtArg with alternate Display formatting, starting with no indentation.

pub const DEBUG: Self

A FmtArg with Debug formatting and no indentation.

pub const ALT_DEBUG: Self

A FmtArg with alternate Debug formatting, starting with no indentation.

pub const BIN: Self

A FmtArg with Debug and Binary formatting and no indentation.

pub const ALT_BIN: Self

A FmtArg with alternate Debug and Binary formatting, starting with no indentation.

pub const HEX: Self

A FmtArg with Debug and Hexadecimal formatting and no indentation.

pub const ALT_HEX: Self

A FmtArg with alternate Debug and Hexadecimal formatting, starting with no indentation.

pub const fn set_alternate(self, is_alternate: bool) -> Self

Sets whether alternate formatting is enabled

pub const fn set_display(self) -> Self

Changes the formatting to Display.

pub const fn set_debug(self) -> Self

Changes the formatting to Debug.

pub const fn set_hex(self) -> Self

Changes the formatting to Debug, and number formatting to Hexadecimal.

pub const fn set_bin(self) -> Self

Changes the formatting to Debug, and number formatting to Binary.

impl FmtArg

pub const fn indent(self) -> Self

Increments the indentation by INDENTATION_STEP spaces.

pub const fn unindent(self) -> Self

Decrement the indentation by INDENTATION_STEP spaces.

Trait Implementations

impl Clone for FmtArg

fn clone(&self) -> FmtArg

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FmtArg

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

Formats the value using the given formatter.

impl PartialEq for FmtArg

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for FmtArg

impl StructuralPartialEq for FmtArg