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

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},
    },
};
/// A generic metadata record with an unknown identifier.
///
/// Applications should generally ignore unknown metadata records.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnknownMetadataRecordObj {
    pub(crate) identifier: VariableLengthEnum,
    data: Vec<u8>,
}

impl Sealed for UnknownMetadataRecordObj {}

impl MetadataRecordObj for UnknownMetadataRecordObj {
    fn token(&self) -> Result<MetadataToken, MetadataTokenError> {
        Err(MetadataTokenError::IdentifierNotRecognized {
            identifier: self.identifier.to_owned(),
        })
    }
    fn byte_length(&self) -> usize {
        self.data.len()
    }
}

impl UnknownMetadataRecordObj {
    pub(crate) fn read_from<C: ?Sized + Config, R: ?Sized + Read>(
        reader: &mut R,
        configuration: &C,
        identifier: VariableLengthEnum,
    ) -> Result<Self, MetadataRecordReadError> {
        let length: usize = VariableLengthEnum::read_from(reader, configuration)?.try_into()?;
        let mut data = Vec::with_capacity(length);
        reader.take(length as u64).read_to_end(&mut data)?;
        Ok(Self { identifier, data })
    }
}

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

    /// Writes the metadata record to a writer.
    ///
    /// Only useful when copying metadata records or converting them from a different format.
    fn write_to<C: ?Sized + Config>(
        &self,
        writer: &mut W,
        configuration: &C,
    ) -> Result<(), Self::WriteError> {
        VariableLengthEnum::from(self.data.len()).write_to(writer, configuration)?;
        writer.write_all(&self.data)?;
        Ok(())
    }
}

impl Into<MetadataRecord> for UnknownMetadataRecordObj {
    fn into(self) -> MetadataRecord {
        MetadataRecord::Unknown(self)
    }
}