Enum Once 

pub enum Once<T> {
    Missing {
        name: &'static str,
    },
    Failure {
        name_range: Range<usize>,
        value_range: Range<usize>,
    },
    Success {
        name_range: Range<usize>,
        value_range: Range<usize>,
        value: T,
    },
}

Variants

Missing

Fields

name: &'static str

Failure

Fields

name_range: Range<usize>

value_range: Range<usize>

Success

Fields

name_range: Range<usize>

value_range: Range<usize>

value: T

Implementations

impl Once<bool>

pub fn boolean_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError> + From<NameError>,

Parse a single boolean (yes/no) attribute

impl Once<DottedPath>

pub fn dotted_path_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError> + From<PathError>,

Parse a single dotted path attribute

impl<T: Clone> Once<T>

pub fn enum_attribute<'input, E>( &mut self, values: &'static [(&'static str, T)], attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError> + From<NameError>,

Parse a single enum attribute

impl<T> Once<T>

pub fn is_duplicate_attribute<'input, E>( &self, attribute: &Attribute<'input, 'input>, errors: &mut Vec<E>, ) -> bool

where E: From<ParseError>,

Is this a duplicate attribute?

If yes, then raise an error.

impl Once<usize>

pub fn length_attribute<'input, E>( &mut self, range: RangeInclusive<usize>, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a single length attribute, a usize with bounded range.

impl Once<LowerName>

pub fn lower_name_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError> + From<NameError>,

Parse a single lowercase name attribute

impl Once<usize>

pub fn number_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a single number attribute, a usize with no bound requirements

impl Once<String>

pub fn string_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a string attribute

impl Once<UpperName>

pub fn upper_name_attribute<'input, E>( &mut self, attribute: Attribute<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError> + From<NameError>,

Parse a single uppercase name attribute

impl<T> Once<T>

pub fn is_duplicate_element<'input, E>( &self, element: &Node<'input, 'input>, errors: &mut Vec<E>, ) -> bool

where E: From<ParseError>,

Check if duplicate element is being parsed.

If a duplicate is being parsed, return true and raise an error.

Otherwise, return false.

impl Once<usize>

pub fn length_element<'input, E>( &mut self, attribute_name: &'static str, range: RangeInclusive<usize>, element: Node<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a single length element, a usize with bounded range.

impl Once<String>

pub fn string_element<'input, E>( &mut self, element: Node<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a string element checking for duplicates

pub fn string_element_ignore_attributes<'input, E>( &mut self, element: Node<'input, 'input>, errors: &mut Vec<E>, )

where E: From<ParseError>,

Parse a string element checking for duplicates

Ignore attributes

impl<T> Once<T>

pub fn new(name: &'static str) -> Self

pub fn attribute_failure<'input>( &mut self, attribute: Attribute<'input, 'input>, )

pub fn attribute_success<'input>( &mut self, attribute: Attribute<'input, 'input>, value: T, )

pub fn default(self, default: T) -> T

pub fn default_with<W>(self, with: W) -> T

where W: FnOnce() -> T,

pub fn element_failure<'input>(&mut self, element: Node<'input, 'input>)

pub fn element_parsed_success<'input>( &mut self, element: Node<'input, 'input>, parsed: Parsed<T>, )

pub fn element_success<'input>( &mut self, element: Node<'input, 'input>, value: T, )

pub fn exist(&self) -> bool

pub fn exist_value(self) -> Option<Option<T>>

pub fn optional(self) -> Option<Option<T>>

pub fn optional_parsed(self) -> Option<Option<Parsed<T>>>

pub fn required_attribute<'input, E>( self, parent: &Node<'input, 'input>, errors: &mut Vec<E>, ) -> Option<T>

where E: From<ParseError>,

pub fn required_element<'input, E>( self, parent: &Node<'input, 'input>, errors: &mut Vec<E>, ) -> Option<T>

where E: From<ParseError>,

Extract value of required element

If it does not exist, raise an error

pub fn required_parsed_attribute<'input, E>( self, parent: &Node<'input, 'input>, errors: &mut Vec<E>, ) -> Option<Parsed<T>>

where E: From<ParseError>,

pub fn success_name_range(self) -> Option<Range<usize>>

pub fn take(&mut self) -> Self

impl Once<bool>

pub fn name_range_if_true(self) -> Option<Range<usize>>

pub fn required_yes_attribute<'input, E>( self, parent: &Node<'input, 'input>, errors: &mut Vec<E>, ) -> bool

where E: From<ParseError>,