jubako 0.4.0

The reference implementation of the Jubako container 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

use crate::bases::*;
use std::fmt::Debug;

const JBK_MAGIC: [u8; 3] = *b"jbk";

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
#[cfg_attr(feature = "explorable_serde", derive(serde::Serialize))]
pub enum PackKind {
    Manifest = b'm',
    Directory = b'd',
    Content = b'c',
    Container = b'C',
}

impl Parsable for PackKind {
    type Output = Self;
    fn parse(parser: &mut impl Parser) -> Result<Self> {
        match parser.read_u8()? {
            b'm' => Ok(PackKind::Manifest),
            b'd' => Ok(PackKind::Directory),
            b'c' => Ok(PackKind::Content),
            b'C' => Ok(PackKind::Container),
            kind => Err(format_error!(&format!("Invalid pack kind {kind}"), parser)),
        }
    }
}
impl SizedParsable for PackKind {
    const SIZE: usize = 1;
}

impl Serializable for PackKind {
    fn serialize(&self, ser: &mut Serializer) -> IoResult<usize> {
        ser.write_u8(*self as u8)
    }
}

pub(crate) struct FullPackKind(pub PackKind);

impl Parsable for FullPackKind {
    type Output = PackKind;
    fn parse(parser: &mut impl Parser) -> Result<Self::Output> {
        let mut magic = [0; 3];
        parser.read_data(&mut magic)?;
        if magic != JBK_MAGIC {
            Err(format_error!("Not a JBK kind", parser))
        } else {
            match parser.read_u8()? {
                b'm' => Ok(PackKind::Manifest),
                b'd' => Ok(PackKind::Directory),
                b'c' => Ok(PackKind::Content),
                b'C' => Ok(PackKind::Container),
                kind => Err(format_error!(&format!("Invalid pack kind {kind}"), parser)),
            }
        }
    }
}

impl SizedParsable for FullPackKind {
    const SIZE: usize = 4;
}

impl Serializable for FullPackKind {
    fn serialize(&self, ser: &mut Serializer) -> IoResult<usize> {
        let mut written = 0;
        written += ser.write_data(b"jbk")?;
        written += self.0.serialize(ser)?;
        Ok(written)
    }
}

#[cfg(feature = "explorable")]
impl graphex::Display for PackKind {
    fn print_content(&self, out: &mut graphex::Output) -> graphex::Result {
        let str = match self {
            Self::Manifest => "Manifest",
            Self::Directory => "Directory",
            Self::Content => "Content",
            Self::Container => "Container",
        };
        writeln!(out, "{}", str)
    }
}