positional 0.4.5

A library to author/parse positional files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use chrono::{DateTime, Utc};
use criterion::{criterion_group, criterion_main, Criterion};
use fake::{Fake, Faker};
use positional::{FromPositionalRow, ToPositionalRow, Writer};

#[derive(FromPositionalRow, ToPositionalRow, Debug)]
struct Data {
    #[field(size = 2)]
    code: String,
    #[field(size = 10)]
    name: String,
    #[field(size = 40, filler = '_', align = "right")]
    created: DateTime<Utc>,
    #[field(size = 10, filler = '0')]
    field: String,
}

impl Data {
    pub fn random() -> Self {
        let mut name = Faker.fake::<String>();
        name.truncate(10);
        let mut field = Faker.fake::<String>();
        field.truncate(10);
        Self {
            code: "00".to_string(),
            name,
            created: Faker.fake::<DateTime<Utc>>(),
            field,
        }
    }
}

#[derive(FromPositionalRow, ToPositionalRow, Debug)]
struct Data2 {
    #[field(size = 2)]
    code: String,
    #[field(size = 10)]
    name: String,
    #[field(size = 40, filler = '_', align = "right")]
    created: DateTime<Utc>,
    #[field(size = 10, filler = '0')]
    field: String,
}

impl Data2 {
    pub fn random() -> Self {
        let mut name = Faker.fake::<String>();
        name.truncate(10);
        let mut field = Faker.fake::<String>();
        field.truncate(10);
        Self {
            code: "01".to_string(),
            name,
            created: Faker.fake::<DateTime<Utc>>(),
            field,
        }
    }
}

#[derive(FromPositionalRow, ToPositionalRow)]
enum AllData {
    #[matcher(&row[0..2] == "00")]
    First(Data),
    #[matcher(&row[0..2] == "01")]
    Second(Data2),
}

fn deserialize_enum(c: &mut Criterion) {
    c.bench_function("deserialize 1.000 enums", |b| {
        b.iter(|| {
            for _ in 1..=1_000 {
                let data = if rand::random::<bool>() {
                    AllData::First(Data::random())
                } else {
                    AllData::Second(Data2::random())
                };
                let writer = Writer::new(vec![data]);
                let row = writer.to_string();
                let _data = AllData::from_positional_row(&row).unwrap();
            }
        })
    });
}

criterion_group! {
    name = benches;
    // This can be any expression that returns a `Criterion` object.
    config = Criterion::default().sample_size(30);
    targets = deserialize_enum
}
criterion_main!(benches);