Struct compile_fmt::Ascii

pub struct Ascii<'a>(/* private fields */);

ASCII string wrapper.

This wrapper is useful for non-constant strings if it can be ensured that a string consists entirely of ASCII chars. This allows decreasing capacity requirements for CompileArgs involving such strings. In the general case, CompileArgs logic must assume that each char in a string can require up to 4 bytes; in case of Ascii strings, this is reduced to 1 byte per char.

Examples

use compile_fmt::{clip, clip_ascii, compile_args, Ascii, CompileArgs};

let s: CompileArgs<10> = compile_args!(
    "[", Ascii::new("test") => clip_ascii(8, "").pad_left(8, ' '), "]"
);
assert_eq!(s.as_str(), "[test    ]");

// The necessary capacity for generic UTF-8 strings is greater
// (34 bytes instead of 10):
let s: CompileArgs<34> = compile_args!(
    "[", "test" => clip(8, "").pad_left(8, ' '), "]"
);
assert_eq!(s.as_str(), "[test    ]");

Implementations

impl<'a> Ascii<'a>

pub const fn new(s: &'a str) -> Self

Wraps the provided string if it consists entirely of ASCII chars.

Panics

Panics if the string contains non-ASCII chars.

Trait Implementations

impl<'a> Clone for Ascii<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Ascii<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Ascii<'a>

fn default() -> Ascii<'a>

Returns the “default value” for a type.

impl FormatArgument for Ascii<'_>

type Details = StrFormat

Formatting specification for the type.

impl<'a> Hash for Ascii<'a>

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<'a> PartialEq<Ascii<'a>> for Ascii<'a>

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

impl<'a> Eq for Ascii<'a>

impl<'a> StructuralEq for Ascii<'a>

impl<'a> StructuralPartialEq for Ascii<'a>