fcmlib 0.1.0

Library to read and write Brother's FCM plotter 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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::io::Write;

use nom::bytes::complete::take;
use nom::combinator::{cond, flat_map, map, map_res};
use nom::multi::{length_count, length_data, length_value};
use nom::number::complete::{le_f32, le_u32};
use nom::sequence::tuple;
use nom::IResult;

use crate::encode::Encode;
use crate::path::Path;
use crate::piece_restrictions::PieceRestrictions;
use crate::util::bool32;
use crate::{path, piece_restrictions};

#[derive(Debug)]
pub struct Piece {
    pub width: u32,
    pub height: u32,
    pub transform: Option<(f32, f32, f32, f32, f32, f32)>,
    pub expansion_limit_value: u32,
    pub reduction_limit_value: u32,
    pub restriction_flags: PieceRestrictions,
    pub label: String,
    pub paths: Vec<Path>,
}

pub(crate) fn read_piece(input: &[u8]) -> IResult<&[u8], Piece> {
    map(
        tuple((
            take(8usize),
            le_u32,
            le_u32,
            flat_map(bool32, |has_transform| {
                cond(
                    has_transform,
                    tuple((le_f32, le_f32, le_f32, le_f32, le_f32, le_f32)),
                )
            }),
            le_u32,
            le_u32,
            piece_restrictions::read_piece_restrictions,
            read_piece_label,
            length_count(le_u32, length_value(le_u32, path::read_path)),
        )),
        |(
            _,
            width,
            height,
            transform,
            expansion_limit_value,
            reduction_limit_value,
            restriction_flags,
            label,
            paths,
        )| Piece {
            width,
            height,
            transform,
            expansion_limit_value,
            reduction_limit_value,
            restriction_flags,
            label,
            paths,
        },
    )(input)
}

fn read_piece_label(input: &[u8]) -> IResult<&[u8], String> {
    map_res(length_data(le_u32), |label_data: &[u8]| {
        if label_data[0] == 1 {
            std::str::from_utf8(&label_data[1..4]).map(String::from)
        } else {
            Ok(String::new())
        }
    })(input)
}

impl Encode for Piece {
    fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
        0u32.encode(buffer)?;
        0u32.encode(buffer)?;
        self.width.encode(buffer)?;
        self.height.encode(buffer)?;
        if let Some(transform) = self.transform {
            1u32.encode(buffer)?;
            transform.0.encode(buffer)?;
            transform.1.encode(buffer)?;
            transform.2.encode(buffer)?;
            transform.3.encode(buffer)?;
            transform.4.encode(buffer)?;
            transform.5.encode(buffer)?;
        } else {
            0u32.encode(buffer)?;
        }
        self.expansion_limit_value.encode(buffer)?;
        self.reduction_limit_value.encode(buffer)?;
        self.restriction_flags.encode(buffer)?;

        4u32.encode(buffer)?;
        if self.label.is_empty() {
            0u32.encode(buffer)?;
        } else {
            1u8.encode(buffer)?;
            buffer.write_all(&self.label.as_bytes()[0..3])?;
        }

        let mut path_data: Vec<Vec<u8>> = vec![];
        for path in &self.paths {
            path_data.push(path.encode_to_vec()?);
        }

        (path_data.len() as u32).encode(buffer)?;
        for path in path_data {
            (path.len() as u32).encode(buffer)?;
            buffer.write_all(&path)?;
        }

        Ok(())
    }
}