x12_alt 0.1.0

Data types for X12 EDI
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::fmt;
use serde::{de, Deserialize, ser, Serialize};
/**1329

See docs at <https://www.stedi.com/edi/x12-005010/element/1329>*/
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DispenseAsWrittenCode {
    ///0 - Not Dispense As Written (DAW)
    Code0,
    ///1 - Physician Dispense As Written (DAW)
    Code1,
    ///2 - Patient Dispense As Written (DAW)
    Code2,
    ///3 - Pharmacy Dispense As Written (DAW)
    Code3,
    ///4 - No generic available
    NoGenericAvailable,
    ///5 - Brand Dispensed as Generic
    BrandDispensedAsGeneric,
    ///6 - Override
    Override,
    ///7 - Substitution Not Allowed-Brand Drug Mandated by Law
    SubstitutionNotAllowedBrandDrugMandatedByLaw,
    ///8 - Substitution Allowed-Generic Drug Not Available in Marketplace
    SubstitutionAllowedGenericDrugNotAvailableInMarketplace,
    ///9 - Other
    Other,
}
impl DispenseAsWrittenCode {
    pub fn code(&self) -> &str {
        {
            use DispenseAsWrittenCode::*;
            match self {
                Code0 => "0",
                Code1 => "1",
                Code2 => "2",
                Code3 => "3",
                NoGenericAvailable => "4",
                BrandDispensedAsGeneric => "5",
                Override => "6",
                SubstitutionNotAllowedBrandDrugMandatedByLaw => "7",
                SubstitutionAllowedGenericDrugNotAvailableInMarketplace => "8",
                Other => "9",
            }
        }
    }
    pub fn from_code(code: &[u8]) -> Option<DispenseAsWrittenCode> {
        use DispenseAsWrittenCode::*;
        match code {
            b"0" => Some(Code0),
            b"1" => Some(Code1),
            b"2" => Some(Code2),
            b"3" => Some(Code3),
            b"4" => Some(NoGenericAvailable),
            b"5" => Some(BrandDispensedAsGeneric),
            b"6" => Some(Override),
            b"7" => Some(SubstitutionNotAllowedBrandDrugMandatedByLaw),
            b"8" => Some(SubstitutionAllowedGenericDrugNotAvailableInMarketplace),
            b"9" => Some(Other),
            _ => None,
        }
    }
    fn description(&self) -> &str {
        use DispenseAsWrittenCode::*;
        match self {
            Code0 => "Not Dispense As Written (DAW)",
            Code1 => "Physician Dispense As Written (DAW)",
            Code2 => "Patient Dispense As Written (DAW)",
            Code3 => "Pharmacy Dispense As Written (DAW)",
            NoGenericAvailable => "No generic available",
            BrandDispensedAsGeneric => "Brand Dispensed as Generic",
            Override => "Override",
            SubstitutionNotAllowedBrandDrugMandatedByLaw => {
                "Substitution Not Allowed-Brand Drug Mandated by Law"
            }
            SubstitutionAllowedGenericDrugNotAvailableInMarketplace => {
                "Substitution Allowed-Generic Drug Not Available in Marketplace"
            }
            Other => "Other",
        }
    }
    fn from_description(description: &str) -> Option<DispenseAsWrittenCode> {
        {
            use DispenseAsWrittenCode::*;
            match description {
                "Not Dispense As Written (DAW)" => Some(Code0),
                "Physician Dispense As Written (DAW)" => Some(Code1),
                "Patient Dispense As Written (DAW)" => Some(Code2),
                "Pharmacy Dispense As Written (DAW)" => Some(Code3),
                "No generic available" => Some(NoGenericAvailable),
                "Brand Dispensed as Generic" => Some(BrandDispensedAsGeneric),
                "Override" => Some(Override),
                "Substitution Not Allowed-Brand Drug Mandated by Law" => {
                    Some(SubstitutionNotAllowedBrandDrugMandatedByLaw)
                }
                "Substitution Allowed-Generic Drug Not Available in Marketplace" => {
                    Some(SubstitutionAllowedGenericDrugNotAvailableInMarketplace)
                }
                "Other" => Some(Other),
                _ => None,
            }
        }
    }
}
impl Serialize for DispenseAsWrittenCode {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ser::Serializer,
    {
        let value = if serializer.is_human_readable() {
            self.description()
        } else {
            self.code()
        };
        serializer.serialize_str(value)
    }
}
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
    type Value = DispenseAsWrittenCode;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Dispense as Written Code")
    }
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        DispenseAsWrittenCode::from_description(v)
            .ok_or_else(|| E::custom(format!("Invalid Dispense as Written Code: {}", v)))
    }
    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        DispenseAsWrittenCode::from_code(v)
            .ok_or_else(|| E::custom(
                format!(
                    "Invalid Dispense as Written Code: {}", std::str::from_utf8(v)
                    .unwrap()
                ),
            ))
    }
}
impl<'de> Deserialize<'de> for DispenseAsWrittenCode {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        if deserializer.is_human_readable() {
            deserializer.deserialize_str(Visitor)
        } else {
            deserializer.deserialize_bytes(Visitor)
        }
    }
}