fef 0.2.3

Rust implementation of a parser of the FEF format
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

use std::io::{Read, Write};

use crate::{
    common::traits::private::Sealed,
    v0::{
        config::Config,
        metadata::{
            error::{MetadataRecordReadError, MetadataRecordWriteError},
            traits::MetadataRecordObj,
            MetadataRecord,
        },
        raw::VariableLengthEnum,
        tokens::{error::MetadataTokenError, MetadataToken},
        traits::{ReadFrom, WriteTo},
    },
};

/// Formula name [metadata record](https://github.com/jiricekcz/fef-specification/blob/main/metadata/keys/Name.md).
///
/// This metadata record contains the name of a formula.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct NameMetadataRecordObj {
    name: String,
}

impl NameMetadataRecordObj {
    /// Creates a new name metadata record.
    pub fn new(name: String) -> Self {
        Self { name }
    }

    /// Returns the name of the formula.
    pub fn name(&self) -> &str {
        &self.name
    }
}

/// Converts the name metadata record into a string.
impl Into<String> for NameMetadataRecordObj {
    fn into(self) -> String {
        self.name
    }
}

impl Sealed for NameMetadataRecordObj {}

impl MetadataRecordObj for NameMetadataRecordObj {
    fn token(&self) -> Result<MetadataToken, MetadataTokenError> {
        Ok(MetadataToken::Name)
    }
    fn byte_length(&self) -> usize {
        let string_length = self.name.len();
        string_length + VariableLengthEnum::min_byte_length_of_usize(string_length)
    }
}

impl<R: ?Sized + Read> ReadFrom<R> for NameMetadataRecordObj {
    type ReadError = MetadataRecordReadError;

    /// Reads a name metadata record from a reader.
    ///
    /// # Example
    /// ```rust
    /// # use fef::v0::metadata::NameMetadataRecordObj;
    /// # use fef::v0::traits::ReadFrom;
    /// # use fef::v0::config::DEFAULT_CONFIG;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let data: Vec<u8> = vec![
    ///     0x0C, // Length of the record
    ///     0x0B, // Length of the string
    ///     b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd', // Name
    /// ];
    /// let mut reader = &mut data.as_slice();
    /// let record = NameMetadataRecordObj::read_from(&mut reader, &DEFAULT_CONFIG)?;
    /// assert_eq!(record.name(), "Hello World");
    /// # Ok(())
    /// # }
    /// ```
    fn read_from<C: ?Sized + Config>(
        reader: &mut R,
        configuration: &C,
    ) -> Result<Self, Self::ReadError> {
        let full_length: usize =
            VariableLengthEnum::read_from(reader, configuration)?.try_into()?;
        let mut reserved_part = reader.take(full_length as u64);
        let name = String::read_from(&mut reserved_part, configuration)?;
        let mut buf = Vec::new();
        reserved_part.read_to_end(&mut buf)?;
        drop(buf);
        Ok(Self::new(name))
    }
}

impl<W: ?Sized + Write> WriteTo<W> for NameMetadataRecordObj {
    type WriteError = MetadataRecordWriteError;

    /// Writes the name metadata record to a writer.
    ///
    /// # Example
    /// ```rust
    /// # use fef::v0::metadata::NameMetadataRecordObj;
    /// # use fef::v0::traits::WriteTo;
    /// # use fef::v0::config::DEFAULT_CONFIG;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut file: Vec<u8> = Vec::new();
    /// let record = NameMetadataRecordObj::new("Hello World".to_string());
    ///
    /// record.write_to(&mut file, &DEFAULT_CONFIG)?;
    ///
    /// let expected_result: Vec<u8> = vec![
    ///     0x0C, // Length of the record
    ///     0x0B, // Length of the string
    ///     b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd', // Name
    /// ];
    /// assert_eq!(file, expected_result);
    /// # Ok(())
    /// # }
    /// ```
    fn write_to<C: ?Sized + Config>(
        &self,
        writer: &mut W,
        configuration: &C,
    ) -> Result<(), Self::WriteError> {
        let byte_length_enum = VariableLengthEnum::from(self.byte_length());
        byte_length_enum.write_to(writer, configuration)?;
        self.name.write_to(writer, configuration)?;
        Ok(())
    }
}

impl Into<MetadataRecord> for NameMetadataRecordObj {
    fn into(self) -> MetadataRecord {
        MetadataRecord::Name(self)
    }
}