Enum Phrase 

pub enum Phrase {
    Char(AttrChar),
    Field(Vec<AttrChar>),
    Full(Vec<Vec<AttrChar>>),
}

Array of fields with optimized data structure

See the module documentation.

Variants

Char(AttrChar)

Phrase having one field containing one character

Phrase::Char(c) is equivalent to Phrase::Field(vec![c]), which in turn equals Phrase::Full(vec![vec![c]]).

Field(Vec<AttrChar>)

Phrase made up of one field

Phrase::Field(chars) is equivalent to Phrase::Full(vec![chars]).

Full(Vec<Vec<AttrChar>>)

Phrase containing any number of fields

Implementations

impl Phrase

pub fn zero_fields() -> Self

Returns a phrase containing no fields.

This function requires no heap allocation.

pub fn one_empty_field() -> Self

Returns a phrase containing one empty field.

This function requires no heap allocation.

pub fn is_zero_fields(&self) -> bool

Tests whether the phrase has no fields.

pub fn field_count(&self) -> usize

Returns the number of fields in the phrase.

pub fn append(&mut self, other: &mut Phrase)

Moves all fields of other into self, leaving other empty.

This function joins two phrases into one. It concatenates the last field of self and the first field of other. Other fields are left intact in the new phrase.

let mut left = Phrase::Full(vec![vec![a], vec![b], vec![c]]);
let mut right = Phrase::Full(vec![vec![d], vec![e], vec![f]]);
left.append(&mut right);
assert_eq!(
    left,
    Phrase::Full(vec![vec![a], vec![b], vec![c, d], vec![e], vec![f]])
);
assert!(right.is_zero_fields());

That implies joining two single-field phrases results in another single-field phrase.

let mut left = Phrase::Field(vec![a, b, c]);
let mut right = Phrase::Field(vec![d, e, f]);
left.append(&mut right);
assert_eq!(left, Phrase::Field(vec![a, b, c, d, e, f]));
assert!(right.is_zero_fields());

let mut left = Phrase::Char(a);
let mut right = Phrase::Char(b);
left.append(&mut right);
assert_eq!(left, Phrase::Field(vec![a, b]));
assert!(right.is_zero_fields());

let mut left = Phrase::one_empty_field();
let mut right = Phrase::one_empty_field();
left.append(&mut right);
assert_eq!(left, Phrase::one_empty_field());
assert_eq!(right, Phrase::zero_fields());

If either phrase is zero fields, the result is the other.

pub fn ifs_join(self, vars: &VariableSet) -> Vec<AttrChar>

Joins this phrase into a single field, separated by the first IFS character.

This function joins self into a single field, separating each original field by the first character of variable IFS. If the variable is not set, fields are separated by a space. If the variable is set but has an empty value, fields are joined without separation.

pub fn for_each_char_mut<F>(&mut self, f: F)

where F: FnMut(&mut AttrChar),

Applies a function to every character in the phrase.

Trait Implementations

impl Add for Phrase

See Phrase::append.

type Output = Phrase

The resulting type after applying the + operator.

fn add(self, other: Phrase) -> Self

Performs the + operation.

impl AddAssign for Phrase

See Phrase::append.

fn add_assign(&mut self, other: Phrase)

Performs the += operation.

impl Clone for Phrase

fn clone(&self) -> Phrase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Phrase

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

Formats the value using the given formatter.

impl From<AttrChar> for Phrase

fn from(c: AttrChar) -> Self

Converts to this type from the input type.

impl From<Phrase> for Vec<Vec<AttrChar>>

fn from(phrase: Phrase) -> Self

Converts to this type from the input type.

impl From<Vec<AttrChar>> for Phrase

fn from(chars: Vec<AttrChar>) -> Self

Converts to this type from the input type.

impl From<Vec<Vec<AttrChar>>> for Phrase

fn from(fields: Vec<Vec<AttrChar>>) -> Self

Converts to this type from the input type.

impl IntoIterator for Phrase

type Item = Vec<AttrChar>

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl PartialEq for Phrase

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