mdf4_rs/blocks/conversion/
types.rs

1/// Represents the conversion type (cc_type) from a conversion block.
2#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4pub enum ConversionType {
5    /// 0: 1:1 conversion (no change)
6    Identity,
7    /// 1: Linear conversion
8    Linear,
9    /// 2: Rational conversion
10    Rational,
11    /// 3: Algebraic conversion (MCD-2 MC text formula)
12    Algebraic,
13    /// 4: Value to value tabular look-up with interpolation
14    TableLookupInterp,
15    /// 5: Value to value tabular look-up without interpolation
16    TableLookupNoInterp,
17    /// 6: Value range to value tabular look-up
18    RangeLookup,
19    /// 7: Value to text/scale conversion tabular look-up
20    ValueToText,
21    /// 8: Value range to text/scale conversion tabular look-up
22    RangeToText,
23    /// 9: Text to value tabular look-up
24    TextToValue,
25    /// 10: Text to text tabular look-up (translation)
26    TextToText,
27    /// 11: Bitfield text table
28    BitfieldText,
29    /// For any other unrecognized conversion type.
30    Unknown(u8),
31}
32
33impl ConversionType {
34    /// Converts a raw u8 value to the corresponding ConversionType.
35    pub fn from_u8(value: u8) -> Self {
36        match value {
37            0 => ConversionType::Identity,
38            1 => ConversionType::Linear,
39            2 => ConversionType::Rational,
40            3 => ConversionType::Algebraic,
41            4 => ConversionType::TableLookupInterp,
42            5 => ConversionType::TableLookupNoInterp,
43            6 => ConversionType::RangeLookup,
44            7 => ConversionType::ValueToText,
45            8 => ConversionType::RangeToText,
46            9 => ConversionType::TextToValue,
47            10 => ConversionType::TextToText,
48            11 => ConversionType::BitfieldText,
49            other => ConversionType::Unknown(other),
50        }
51    }
52
53    /// Convert the `ConversionType` to its numeric representation.
54    pub fn to_u8(self) -> u8 {
55        match self {
56            ConversionType::Identity => 0,
57            ConversionType::Linear => 1,
58            ConversionType::Rational => 2,
59            ConversionType::Algebraic => 3,
60            ConversionType::TableLookupInterp => 4,
61            ConversionType::TableLookupNoInterp => 5,
62            ConversionType::RangeLookup => 6,
63            ConversionType::ValueToText => 7,
64            ConversionType::RangeToText => 8,
65            ConversionType::TextToValue => 9,
66            ConversionType::TextToText => 10,
67            ConversionType::BitfieldText => 11,
68            ConversionType::Unknown(v) => v,
69        }
70    }
71}
72
73impl core::fmt::Display for ConversionType {
74    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
75        match self {
76            ConversionType::Identity => write!(f, "identity"),
77            ConversionType::Linear => write!(f, "linear"),
78            ConversionType::Rational => write!(f, "rational"),
79            ConversionType::Algebraic => write!(f, "algebraic"),
80            ConversionType::TableLookupInterp => write!(f, "table (interpolated)"),
81            ConversionType::TableLookupNoInterp => write!(f, "table"),
82            ConversionType::RangeLookup => write!(f, "range lookup"),
83            ConversionType::ValueToText => write!(f, "value to text"),
84            ConversionType::RangeToText => write!(f, "range to text"),
85            ConversionType::TextToValue => write!(f, "text to value"),
86            ConversionType::TextToText => write!(f, "text to text"),
87            ConversionType::BitfieldText => write!(f, "bitfield text"),
88            ConversionType::Unknown(v) => write!(f, "unknown({})", v),
89        }
90    }
91}