Enum Specifier

#[non_exhaustive]
pub enum Specifier<'a> {
    Percent,
    Int(SignedInt),
    Uint(UnsignedInt),
    Octal(UnsignedInt),
    Double {
        value: f64,
        format: DoubleFormat,
    },
    Bytes(&'a [u8]),
    String(&'a CStr),
    Char(u8),
    Hex(UnsignedInt),
    UpperHex(UnsignedInt),
    Pointer(*const ()),
    WriteBytesWritten(c_int, *const c_int),
}

A format specifier.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Percent

%

Int(SignedInt)

d, i

Uint(UnsignedInt)

u

Octal(UnsignedInt)

o

Double

f, F, e, E, g, G, a, A

Fields

value: f64

format: DoubleFormat

Bytes(&'a [u8])

string outside of formatting

String(&'a CStr)

s

The same as Bytes but guaranteed to be null-terminated. This can be used for optimizations, where if you need to null terminate a string to print it, you can skip that step.

Char(u8)

c

Hex(UnsignedInt)

x

UpperHex(UnsignedInt)

X

Pointer(*const ())

p

WriteBytesWritten(c_int, *const c_int)

n

Safety

This can be a serious security vulnerability if the format specifier of printf is allowed to be user-specified. This shouldn’t ever happen, but poorly-written software may do so.

Trait Implementations

impl<'a> Clone for Specifier<'a>

fn clone(&self) -> Specifier<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Specifier<'a>

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

Formats the value using the given formatter.

impl<'a> From<Specifier<'a>> for Argument<'a>

fn from(specifier: Specifier<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Specifier<'a>

fn eq(&self, other: &Specifier<'a>) -> 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<'a> Copy for Specifier<'a>

impl<'a> StructuralPartialEq for Specifier<'a>