hl7-parser 0.3.0

Parses the structure of HL7v2 messages, but does not validate the correctness of the messages.
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
122
123
124
125
126
127
128

use crate::message::{Component, Field, Repeat, Separators, Subcomponent};
use std::fmt::Display;

/// A display implementation for segments.
/// This will decode the escape sequences in the segment value
/// using the separators. If the `#` flag is used, the raw value
/// will be displayed without decoding the escape sequences.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct SegmentDisplay<'m> {
    pub(crate) name: &'m str,
    pub(crate) fields: &'m Vec<Field<'m>>,
    pub(crate) separators: &'m Separators,
}

impl Display for SegmentDisplay<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)?;
        for field in self.fields {
            write!(f, "{}", self.separators.field)?;
            if f.alternate() {
                write!(f, "{:#}", field.display(self.separators))?;
            } else {
                write!(f, "{}", field.display(self.separators))?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct FieldDisplay<'m> {
    pub(crate) repeats: &'m Vec<Repeat<'m>>,
    pub(crate) separators: &'m Separators,
}

impl Display for FieldDisplay<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut first: bool = true;
        for repeat in self.repeats {
            if first {
                first = false;
            } else {
                write!(f, "{}", self.separators.repetition)?;
            }
            if f.alternate() {
                write!(f, "{:#}", repeat.display(self.separators))?;
            } else {
                write!(f, "{}", repeat.display(self.separators))?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct RepeatDisplay<'m> {
    pub(crate) components: &'m Vec<Component<'m>>,
    pub(crate) separators: &'m Separators,
}

impl Display for RepeatDisplay<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut first: bool = true;
        for component in self.components {
            if first {
                first = false;
            } else {
                write!(f, "{}", self.separators.repetition)?;
            }
            if f.alternate() {
                write!(f, "{:#}", component.display(self.separators))?;
            } else {
                write!(f, "{}", component.display(self.separators))?;
            }
        }
        Ok(())
    }
}

/// A display implementation for components.
/// This will decode the escape sequences in the component values
/// using the separators. If the `#` flag is used, the raw value
/// will be displayed without decoding the escape sequences.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct ComponentDisplay<'m> {
    pub(crate) subcomponents: &'m Vec<Subcomponent<'m>>,
    pub(crate) separators: &'m Separators,
}

impl Display for ComponentDisplay<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        //     write!(f, "{}", self.separators.decode(self.value))
        let mut first: bool = true;
        for subcomponent in self.subcomponents {
            if first {
                first = false;
            } else {
                write!(f, "{}", self.separators.subcomponent)?;
            }
            if f.alternate() {
                write!(f, "{}", subcomponent.value)?;
            } else {
                write!(f, "{}", subcomponent.display(self.separators))?;
            }
        }
        Ok(())
    }
}

/// A display implementation for subcomponents.
/// This will decode the escape sequences in the subcomponent value
/// using the separators. If the `#` flag is used, the raw value
/// will be displayed without decoding the escape sequences.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct SubcomponentDisplay<'m> {
    pub(crate) value: &'m str,
    pub(crate) separators: &'m Separators,
}

impl Display for SubcomponentDisplay<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if f.alternate() {
            write!(f, "{}", self.value)
        } else {
            write!(f, "{}", self.separators.decode(self.value))
        }
    }
}