outlook-pst 0.1.2

Outlook PST Store Provider 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

//! [IB (Byte Index)](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-pst/7d53d413-b492-4483-b624-4e2fa2a08cf3)

use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::{
    fmt::Debug,
    io::{self, Read, Write},
};

use super::read_write::*;

pub trait ByteIndex {
    type Index: Copy + Sized + Into<u64>;

    fn index(&self) -> Self::Index;
}

#[derive(Clone, Copy, Default)]
pub struct UnicodeByteIndex(u64);

impl UnicodeByteIndex {
    pub fn new(index: u64) -> Self {
        Self(index)
    }
}

impl ByteIndex for UnicodeByteIndex {
    type Index = u64;

    fn index(&self) -> u64 {
        self.0
    }
}

impl ByteIndexReadWrite for UnicodeByteIndex {
    fn new(index: u64) -> Self {
        Self::new(index)
    }

    fn read(f: &mut dyn Read) -> io::Result<Self> {
        let value = f.read_u64::<LittleEndian>()?;
        Ok(Self(value))
    }

    fn write(&self, f: &mut dyn Write) -> io::Result<()> {
        f.write_u64::<LittleEndian>(self.0)
    }
}

impl Debug for UnicodeByteIndex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UnicodeByteIndex {{ 0x{:X} }}", self.index())
    }
}

impl From<u64> for UnicodeByteIndex {
    fn from(value: u64) -> Self {
        Self::new(value)
    }
}

impl From<UnicodeByteIndex> for u64 {
    fn from(value: UnicodeByteIndex) -> Self {
        value.index()
    }
}

#[derive(Clone, Copy, Default)]
pub struct AnsiByteIndex(u32);

impl AnsiByteIndex {
    pub fn new(index: u32) -> Self {
        Self(index)
    }
}

impl ByteIndex for AnsiByteIndex {
    type Index = u32;

    fn index(&self) -> u32 {
        self.0
    }
}

impl ByteIndexReadWrite for AnsiByteIndex {
    fn new(index: u32) -> Self {
        Self::new(index)
    }

    fn read(f: &mut dyn Read) -> io::Result<Self> {
        let value = f.read_u32::<LittleEndian>()?;
        Ok(Self(value))
    }

    fn write(&self, f: &mut dyn Write) -> io::Result<()> {
        f.write_u32::<LittleEndian>(self.0)
    }
}

impl Debug for AnsiByteIndex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "AnsiByteIndex {{ 0x{:X} }}", self.index())
    }
}

impl From<u32> for AnsiByteIndex {
    fn from(value: u32) -> Self {
        Self::new(value)
    }
}

impl From<AnsiByteIndex> for u32 {
    fn from(value: AnsiByteIndex) -> Self {
        value.index()
    }
}