galaxy_save_core 0.2.0

Defining common types and traits used in the save data of Super Mario Galaxy and Super Mario Galaxy 2
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

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

use binrw::{BinRead, BinResult, BinWrite, Endian};

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::hash::HashCode;

/// A block of data.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
#[derive(Debug)]
pub struct BinaryDataChunk<T>
where
    T: BinRead + BinWrite + Chunk,
    T: for<'a> BinRead<Args<'a> = (usize,)>,
    T: for<'a> BinWrite<Args<'a> = ()>,
{
    /*
    /// The hash digest identifying the data block.
    #[br(temp)]
    _hash_code: HashCode,

    /// The size of the data block, in bytes.
    #[br(temp)]
    _data_size: u32,
    */
    /// The wrapped value.
    pub inner: T,
}

impl<T> BinaryDataChunk<T>
where
    T: BinRead + BinWrite + Chunk,
    T: for<'a> BinRead<Args<'a> = (usize,)>,
    T: for<'a> BinWrite<Args<'a> = ()>,
{
    /// The data alignment factor for little-endian architectures.
    const ALIGNMENT_LE: u64 = 4;
}

impl<T> BinRead for BinaryDataChunk<T>
where
    T: BinRead + BinWrite + Chunk,
    T: for<'a> BinRead<Args<'a> = (usize,)>,
    T: for<'a> BinWrite<Args<'a> = ()>,
{
    type Args<'a> = ();

    fn read_options<R: Read + Seek>(
        reader: &mut R,
        endian: Endian,
        _args: Self::Args<'_>,
    ) -> BinResult<Self> {
        let hash_pos = reader.stream_position()?;
        let hash = HashCode::read_options(reader, endian, ())?;
        let expected_hash = T::hash_code();

        if hash != expected_hash {
            return Err(binrw::Error::AssertFail {
                pos: hash_pos,
                message: format!(
                    "expected hash digest {:#X}, found {:#X}",
                    expected_hash.into_raw(),
                    hash.into_raw()
                ),
            });
        }

        let header_size = size_of::<u32>() + size_of::<HashCode>() + size_of::<u32>();
        let expected_data_size = u32::read_options(reader, endian, ())? as usize;
        let inner = T::read_options(reader, endian, (expected_data_size - header_size,))?;
        let end_pos = match endian {
            Endian::Big => reader.stream_position()?,
            Endian::Little => reader
                .stream_position()?
                .next_multiple_of(Self::ALIGNMENT_LE),
        };

        reader.seek(SeekFrom::Start(end_pos))?;

        let data_size = (end_pos - (hash_pos - size_of::<u32>() as u64)) as usize;

        if data_size != expected_data_size {
            return Err(binrw::Error::AssertFail {
                pos: end_pos,
                message: format!(
                    "expected to read {expected_data_size} bytes, read {data_size} bytes",
                ),
            });
        }

        Ok(Self { inner })
    }
}

impl<T> BinWrite for BinaryDataChunk<T>
where
    T: BinRead + BinWrite + Chunk,
    T: for<'a> BinRead<Args<'a> = (usize,)>,
    T: for<'a> BinWrite<Args<'a> = ()>,
{
    type Args<'a> = ();

    fn write_options<W: Write + Seek>(
        &self,
        writer: &mut W,
        endian: Endian,
        _args: Self::Args<'_>,
    ) -> BinResult<()> {
        let start_pos = writer.stream_position()? - size_of::<u32>() as u64;
        let hash_code = T::hash_code();

        hash_code.write_options(writer, endian, ())?;

        let size_pos = writer.stream_position()?;

        writer.seek_relative(size_of::<u32>() as i64)?;

        self.inner.write_options(writer, endian, ())?;

        let end_pos = match endian {
            Endian::Big => writer.stream_position()?,
            Endian::Little => writer
                .stream_position()?
                .next_multiple_of(Self::ALIGNMENT_LE),
        };
        let data_size = (end_pos - start_pos) as u32;

        writer.seek(SeekFrom::Start(size_pos))?;
        data_size.write_options(writer, endian, ())?;
        writer.seek(SeekFrom::Start(end_pos))?;

        Ok(())
    }
}

/// A trait for types which must be represented as a data block.
pub trait Chunk {
    /// Returns the hash digest identifying the data block.
    fn hash_code() -> HashCode;
}