portable-network-archive 0.32.2

Portable-Network-Archive cli
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

#[cfg(feature = "memmap")]
use std::borrow::Cow;
use std::{fs, io};

use pna::{NormalEntry, ReadEntry};

use super::TransformStrategy;

pub(crate) struct SplitArchiveReader {
    #[cfg(feature = "memmap")]
    mmaps: Vec<crate::utils::mmap::Mmap>,
    #[cfg(not(feature = "memmap"))]
    files: Vec<fs::File>,
}

impl SplitArchiveReader {
    pub(crate) fn new(files: Vec<fs::File>) -> io::Result<Self> {
        #[cfg(feature = "memmap")]
        {
            let mmaps = files
                .into_iter()
                .map(crate::utils::mmap::Mmap::try_from)
                .collect::<io::Result<Vec<_>>>()?;
            Ok(Self { mmaps })
        }
        #[cfg(not(feature = "memmap"))]
        {
            Ok(Self { files })
        }
    }

    #[cfg(not(feature = "memmap"))]
    pub(crate) fn transform_entries<W, F, S>(
        &mut self,
        writer: W,
        password: Option<&[u8]>,
        processor: F,
        strategy: S,
    ) -> anyhow::Result<()>
    where
        W: io::Write,
        F: FnMut(io::Result<NormalEntry>) -> io::Result<Option<NormalEntry>>,
        S: TransformStrategy,
    {
        super::run_transform_entry(
            writer,
            self.files.drain(..),
            || password,
            processor,
            strategy,
        )
    }

    #[cfg(feature = "memmap")]
    pub(crate) fn transform_entries<'s, W, F, S>(
        &'s mut self,
        writer: W,
        password: Option<&[u8]>,
        processor: F,
        strategy: S,
    ) -> anyhow::Result<()>
    where
        W: io::Write,
        F: FnMut(
            io::Result<NormalEntry<Cow<'s, [u8]>>>,
        ) -> io::Result<Option<NormalEntry<Cow<'s, [u8]>>>>,
        S: TransformStrategy,
    {
        super::run_transform_entry(
            writer,
            self.mmaps.iter().map(|m| m.as_ref()),
            || password,
            processor,
            strategy,
        )
    }

    #[cfg(not(feature = "memmap"))]
    pub(crate) fn for_each_entry(
        &mut self,
        password: Option<&[u8]>,
        processor: impl FnMut(io::Result<NormalEntry>) -> io::Result<()>,
    ) -> io::Result<()> {
        super::run_process_archive(self.files.drain(..), || password, processor, false)
    }

    #[cfg(feature = "memmap")]
    pub(crate) fn for_each_entry<'s>(
        &'s mut self,
        password: Option<&[u8]>,
        mut processor: impl FnMut(io::Result<NormalEntry<Cow<'s, [u8]>>>) -> io::Result<()>,
    ) -> io::Result<()> {
        super::run_read_entries_mem(
            self.mmaps.iter().map(|m| m.as_ref()),
            |entry| match entry? {
                ReadEntry::Solid(s) => s
                    .entries(password)?
                    .try_for_each(|r| processor(r.map(Into::into))),
                ReadEntry::Normal(n) => processor(Ok(n)),
            },
            false,
        )
    }

    #[cfg(not(feature = "memmap"))]
    pub(crate) fn for_each_read_entry(
        &mut self,
        processor: impl FnMut(io::Result<ReadEntry>) -> io::Result<()>,
        allow_concatenated_archives: bool,
    ) -> io::Result<()> {
        super::run_read_entries(self.files.drain(..), processor, allow_concatenated_archives)
    }

    #[cfg(feature = "memmap")]
    pub(crate) fn for_each_read_entry<'s>(
        &'s mut self,
        processor: impl FnMut(io::Result<ReadEntry<Cow<'s, [u8]>>>) -> io::Result<()>,
        allow_concatenated_archives: bool,
    ) -> io::Result<()> {
        super::run_read_entries_mem(
            self.mmaps.iter().map(|m| m.as_ref()),
            processor,
            allow_concatenated_archives,
        )
    }
}