zpl-forge 0.2.1

A fast, memory-safe ZPL (Zebra Programming Language) parser and renderer.
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

/// Represents text justification options in ZPL.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Justification {
    /// Left justification (Default)
    L,
    /// Center justification
    C,
    /// Right justification
    R,
    /// Justified (full width)
    J,
}

impl From<char> for Justification {
    fn from(value: char) -> Self {
        match value {
            'L' => Justification::L,
            'C' => Justification::C,
            'R' => Justification::R,
            'J' => Justification::J,
            _ => {
                tracing::debug!(
                    target: crate::TARGET,
                    "{} is not a valid Justification value, using L as default",
                    value
                );
                Justification::L
            }
        }
    }
}

impl From<Justification> for char {
    fn from(value: Justification) -> Self {
        match value {
            Justification::L => 'L',
            Justification::C => 'C',
            Justification::R => 'R',
            Justification::J => 'J',
        }
    }
}

impl From<Justification> for String {
    fn from(value: Justification) -> Self {
        let c: char = value.into();
        c.to_string()
    }
}

/// Represents a boolean-like state in ZPL (Yes/No).
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum YesNo {
    /// Yes ('Y')
    Y,
    /// No ('N')
    N,
}

impl From<char> for YesNo {
    fn from(value: char) -> Self {
        match value {
            'Y' => YesNo::Y,
            'N' => YesNo::N,
            _ => {
                tracing::debug!(
                    target: crate::TARGET,
                    "{} is not a valid YesNo value, using N as default",
                    value
                );
                YesNo::N
            }
        }
    }
}

impl From<YesNo> for char {
    fn from(value: YesNo) -> Self {
        match value {
            YesNo::Y => 'Y',
            YesNo::N => 'N',
        }
    }
}

impl From<bool> for YesNo {
    fn from(value: bool) -> Self {
        if value { YesNo::Y } else { YesNo::N }
    }
}

impl From<YesNo> for bool {
    fn from(value: YesNo) -> Self {
        match value {
            YesNo::Y => true,
            YesNo::N => false,
        }
    }
}