Struct AllowedSpecifier 

pub struct AllowedSpecifier {
    pub types: u16,
    pub alternate_forms: u8,
    pub allowed_fill_characters: Option<String>,
    pub forbidden_fill_characters: Option<String>,
    pub alignments: u8,
    pub signs: u8,
    pub pad_zeros: u8,
    pub allowed_widths: Option<Vec<Width>>,
    pub forbidden_widths: Option<Vec<Width>>,
    pub allowed_precisions: Option<Vec<Precision>>,
    pub forbidden_precisions: Option<Vec<Precision>>,
}

Helper structure to specify the constraints of an expected argument.

use dfmt::*;

let allowed_specifier =
    AllowedSpecifier::all()
        .forbid(Type::Display);

assert!(Template::parse("Hello, {world}!").unwrap()
    .expect_argument("world", &allowed_specifier)
    .is_err());

Fields

types: u16

alternate_forms: u8

allowed_fill_characters: Option<String>

forbidden_fill_characters: Option<String>

alignments: u8

signs: u8

pad_zeros: u8

allowed_widths: Option<Vec<Width>>

forbidden_widths: Option<Vec<Width>>

allowed_precisions: Option<Vec<Precision>>

forbidden_precisions: Option<Vec<Precision>>

Implementations

impl AllowedSpecifier

pub fn all() -> Self

pub fn none() -> Self

pub fn is_within_constraints(&self, specifier: &Specifier) -> bool

Trait Implementations

impl AllowedSpecifierBuilder<Alignment> for AllowedSpecifier

fn allow(self, constraint: Alignment) -> Self

fn forbid(self, constraint: Alignment) -> Self

impl AllowedSpecifierBuilder<AlternateForm> for AllowedSpecifier

fn allow(self, constraint: AlternateForm) -> Self

fn forbid(self, constraint: AlternateForm) -> Self

impl AllowedSpecifierBuilder<Option<String>> for AllowedSpecifier

fn allow(self, constraint: Option<String>) -> Self

fn forbid(self, constraint: Option<String>) -> Self

impl AllowedSpecifierBuilder<Option<Vec<Precision>>> for AllowedSpecifier

fn allow(self, constraint: Option<Vec<Precision>>) -> Self

fn forbid(self, constraint: Option<Vec<Precision>>) -> Self

impl AllowedSpecifierBuilder<Option<Vec<Width>>> for AllowedSpecifier

fn allow(self, constraint: Option<Vec<Width>>) -> Self

fn forbid(self, constraint: Option<Vec<Width>>) -> Self

impl AllowedSpecifierBuilder<PadZero> for AllowedSpecifier

fn allow(self, constraint: PadZero) -> Self

fn forbid(self, constraint: PadZero) -> Self

impl AllowedSpecifierBuilder<Precision> for AllowedSpecifier

fn allow(self, constraint: Precision) -> Self

fn forbid(self, constraint: Precision) -> Self

impl AllowedSpecifierBuilder<Sign> for AllowedSpecifier

fn allow(self, constraint: Sign) -> Self

fn forbid(self, constraint: Sign) -> Self

impl AllowedSpecifierBuilder<Type> for AllowedSpecifier

fn allow(self, constraint: Type) -> Self

fn forbid(self, constraint: Type) -> Self

impl AllowedSpecifierBuilder<Width> for AllowedSpecifier

fn allow(self, constraint: Width) -> Self

fn forbid(self, constraint: Width) -> Self

impl Clone for AllowedSpecifier

fn clone(&self) -> AllowedSpecifier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AllowedSpecifier

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

Formats the value using the given formatter.

impl PartialEq for AllowedSpecifier

fn eq(&self, other: &AllowedSpecifier) -> 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 Eq for AllowedSpecifier

impl StructuralPartialEq for AllowedSpecifier