phar 0.0.3

Rust library for PHP phar 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
84
85
86
87
88
89
90
91

use std::borrow::Cow;
use std::convert::{TryFrom, TryInto};
use std::io::{self, Read, Result, Seek, SeekFrom, Write};

#[derive(Debug, Clone)]
pub enum Section {
    Cached(Vec<u8>),
    Offset(u64, u64),
}

impl Section {
    pub fn create(cache: bool, start: u64) -> Self {
        if cache {
            Self::Cached(Vec::new())
        } else {
            Self::Offset(start, start)
        }
    }

    pub fn feed(&mut self, bytes: &[u8]) {
        match self {
            Self::Cached(vec) => vec.extend(bytes),
            Self::Offset(_, end) => {
                *end += u64::try_from(bytes.len()).expect("usize <= u64");
            }
        }
    }

    pub fn from_read(&mut self, read: &mut (impl Read + Seek), len: u32) -> Result<()> {
        match self {
            Self::Cached(vec) => {
                let _ = read
                    .take(len.try_into().expect("u32 <= usize"))
                    .read_to_end(vec)?;
            }
            Self::Offset(_, end) => {
                let _ = read.seek(SeekFrom::Current(len.into()))?;
                let len: u64 = len.into();
                *end += len;
            }
        }
        Ok(())
    }

    pub fn len(&self) -> u64 {
        match self {
            Self::Cached(vec) => vec.len().try_into().expect("usize <= u64"),
            Self::Offset(start, end) => end - start,
        }
    }

    pub fn copy_value(&self, read: &mut (impl Read + Seek), mut write: impl Write) -> Result<()> {
        match self {
            Self::Cached(vec) => {
                write.write_all(&vec[..])?;
            }
            Self::Offset(start, end) => {
                let _ = read.seek(SeekFrom::Start(*start))?;
                let _ = io::copy(&mut read.take(end - start), &mut write)?;
            }
        }
        Ok(())
    }

    pub fn as_memory<'t>(&'t self, read: &mut (impl Read + Seek)) -> Result<impl AsRef<[u8]> + 't> {
        Ok(match self {
            Self::Cached(vec) => Cow::Borrowed(&vec[..]),
            Self::Offset(start, end) => {
                // overflow is impossible for filenames because they are u32
                let size = (end - start)
                    .try_into()
                    .expect("section is too large to fit in memory");
                let mut vec = Vec::with_capacity(size);
                self.copy_value(read, &mut vec)?;
                Cow::Owned(vec)
            }
        })
    }

    #[auto_enums::auto_enum(Transpose, Read)]
    pub fn as_read<'t>(&'t self, read: &'t mut (impl Read + Seek)) -> Result<impl Read + 't> {
        match self {
            Self::Cached(vec) => Ok(io::Cursor::new(&vec[..])),
            Self::Offset(start, end) => {
                let _ = read.seek(SeekFrom::Start(*start))?;
                Ok(read.take(*end - *start))
            }
        }
        .transpose_ok()
    }
}