resource-fork-types 0.1.1

Support for reading common resource fork types in rust
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

use binrw::{binread, BinRead, BinReaderExt};
use resource_fork::Resource;

pub fn roman_char(input: u8) -> Option<char> {
    if input == 0 {
        return None;
    }

    let input = [input];

    encoding_rs::MACINTOSH
        .decode(&input)
        .0
        .to_string()
        .chars()
        .next()
}

#[binread]
#[derive(Debug)]
pub struct LongArray<T: BinRead + 'static>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    #[br(temp)]
    count: u16,

    #[br(count(count))]
    pub(crate) items: Vec<T>,
}

pub fn long_list<T: BinRead>(input: LongArray<T>) -> Vec<T>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    input.items
}

#[binread]
pub(crate) struct LongArrayPlusOne<T: BinRead + 'static>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    #[br(temp)]
    last_index: u16,

    #[br(temp, calc(if last_index == 0xFFFF { 0 } else {last_index as usize +1} ))]
    count: usize,

    #[br(count(count))]
    pub(crate) items: Vec<T>,
}

pub(crate) fn long_list_plus_one<T: BinRead>(input: LongArrayPlusOne<T>) -> Vec<T>
where
    for<'a> <T as BinRead>::Args<'a>: Default + Clone,
{
    input.items
}

#[derive(BinRead)]
#[br(import_raw(args: <T as BinRead>::Args<'_>))]
enum ListItem<T: BinRead> {
    #[br(magic(0u8))]
    None,
    Some(#[br(args_raw = args)] T),
}

pub(crate) struct NullTerminatedList<T: BinRead>
where
    for<'a> <T as BinRead>::Args<'a>: Clone,
{
    items: Vec<T>,
}

impl<T: BinRead> BinRead for NullTerminatedList<T>
where
    for<'a> <T as BinRead>::Args<'a>: Clone,
{
    type Args<'a> = <T as BinRead>::Args<'a>;

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        endian: binrw::Endian,
        args: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        let mut items = Vec::new();

        loop {
            match reader.read_type_args::<ListItem<T>>(endian, args.clone())? {
                ListItem::None => return Ok(Self { items }),
                ListItem::Some(item) => items.push(item),
            }
        }
    }
}

pub(crate) fn null_terminated_list<T: binrw::BinRead>(list: NullTerminatedList<T>) -> Vec<T>
where
    for<'a> <T as BinRead>::Args<'a>: Clone,
{
    list.items
}

#[binread]
pub(crate) struct LengthPrefixedBuffer {
    #[br(temp)]
    len: u8,

    #[br(count(len))]
    contents: Vec<u8>,
}

impl From<LengthPrefixedBuffer> for Vec<u8> {
    fn from(val: LengthPrefixedBuffer) -> Self {
        val.contents
    }
}

#[derive(Debug, Copy, Clone, BinRead, Resource)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[resource(code = "RECT")]
#[br(big)]
pub struct Rect {
    pub top: i16,
    pub left: i16,
    pub bottom: i16,
    pub right: i16,
}

impl Rect {
    pub fn width(&self) -> i32 {
        self.right as i32 - self.left as i32
    }

    pub fn height(&self) -> i32 {
        self.bottom as i32 - self.top as i32
    }
}

#[derive(Debug, Copy, Clone, BinRead, Resource)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[resource(code = "PNT ")]
pub struct Point {
    pub x: i16,
    pub y: i16,
}