Enum FieldSet 

pub enum FieldSet {
    Item(FieldConfig),
    Seq(Vec<FieldSet>),
}

Field structure definition.

Variants

Item(FieldConfig)

For single Field

Seq(Vec<FieldSet>)

For Sequence of Fields

Implementations

impl FieldSet

pub fn new_field(range: Range<usize>) -> Self

Create a new field.

use fixed_width::FieldSet;

let field = FieldSet::new_field(0..1);

pub fn name<T: Into<String>>(self, val: T) -> Self

Sets the name of this field. Mainly used when deserializing into a HashMap to derive the keys. (This method is not valid on FieldSet::Seq and cause panic)

use fixed_width::FieldSet;

let fields = FieldSet::Seq(vec![
    FieldSet::new_field(0..1).name("foo"),
    FieldSet::Seq(vec![
        FieldSet::new_field(0..2).name("bar"), FieldSet::new_field(0..3).name("baz")
    ])
]);

pub fn pad_with(self, val: char) -> Self

Sets the character to use as padding the value of this field to its byte width.

Example

use fixed_width::FieldSet;

let field = FieldSet::new_field(0..1).pad_with('x');
let fields = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::Seq(vec![FieldSet::new_field(0..2), FieldSet::new_field(0..3)]),
])
.pad_with('x');

pub fn justify<T: Into<Justify>>(self, val: T) -> Self

Sets the justification to use fields. Left will align to the left and Right to the right.

Example

use fixed_width::{FieldSet, Justify};

let field = FieldSet::new_field(0..1).justify(Justify::Right);
let fields = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::Seq(vec![FieldSet::new_field(0..2), FieldSet::new_field(0..3)]),
])
.justify(Justify::Right);

pub fn append(self, item: Self) -> Self

Append FieldSet with the given item.

Example

use fixed_width::FieldSet;

// Suppose field defined as:
let append_fields_1 = FieldSet::new_field(0..1).append(FieldSet::new_field(1..2));
let append_fields_2 = FieldSet::new_field(0..1).append(
    FieldSet::Seq(vec![
        FieldSet::new_field(1..2),
        FieldSet::new_field(2..3),
    ])
);

// Are identical to:
let fields_1 = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::new_field(1..2),
]);
let fields_2 = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::Seq(vec![
        FieldSet::new_field(1..2),
        FieldSet::new_field(2..3),
    ]),
]);

pub fn extend(self, item: Self) -> Self

Extend FieldSet with the given item.

Example

use fixed_width::FieldSet;

// Suppose field defined as:
let extend_fields_1 = FieldSet::new_field(0..1).extend(FieldSet::new_field(1..2));
let extend_fields_2 = FieldSet::new_field(0..1).extend(
    FieldSet::Seq(vec![
        FieldSet::new_field(1..2),
        FieldSet::new_field(2..3),
    ])
);

// Are identical to:
let fields_1 = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::new_field(1..2),
]);
let fields_2 = FieldSet::Seq(vec![
    FieldSet::new_field(0..1),
    FieldSet::new_field(1..2),
    FieldSet::new_field(2..3),
]);

pub fn flatten(self) -> Vec<FieldConfig>

Converts FieldSet into flatten Vec<FieldConfig>.

Example

use fixed_width::{FieldConfig, FieldSet};

let fields = FieldSet::Seq(vec![
    FieldSet::Seq(vec![FieldSet::new_field(0..1), FieldSet::new_field(1..2)]),
    FieldSet::new_field(2..3)
]);
let flatten_fields = vec![
    FieldConfig::new(0..1), FieldConfig::new(1..2), FieldConfig::new(2..3)
];

assert_eq!(format!("{:?}", fields.flatten()), format!("{:?}", flatten_fields));

Trait Implementations

impl Clone for FieldSet

fn clone(&self) -> FieldSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FieldSet

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

Formats the value using the given formatter.

impl IntoIterator for FieldSet

type Item = FieldSet

The type of the elements being iterated over.

type IntoIter = IntoIter<FieldSet>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.