bale 0.1.0

A mmap-first, fixed-stride zip-like pack 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
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

//! Generic entry wrapper for any archive entry type.

use crate::archive::{DirEntry, FileEntry, SymlinkEntry};

/// An entry in the archive of any type.
///
/// This enum provides generic access to archive entries when the caller
/// needs to handle any entry type. For type-specific access, use
/// [`ArchiveRead::file`], [`ArchiveRead::folder`], or the entry's
/// conversion methods.
///
/// # Example
///
/// ```ignore
/// match archive.entry("some/path")? {
///     Entry::File(f) => println!("file: {} bytes", f.size()),
///     Entry::Directory(d) => println!("dir: {}", d.path()),
///     Entry::Symlink(s) => println!("link -> {}", s.target().unwrap_or("<binary>")),
/// }
/// ```
#[derive(Debug)]
pub enum Entry<'a> {
    /// A regular file entry.
    File(FileEntry<'a>),
    /// A directory entry.
    Directory(DirEntry<'a>),
    /// A symbolic link entry.
    Symlink(SymlinkEntry<'a>),
}

impl<'a> Entry<'a> {
    /// Returns `true` if this is a file entry.
    #[must_use]
    pub fn is_file(&self) -> bool {
        matches!(self, Self::File(_))
    }

    /// Returns `true` if this is a directory entry.
    #[must_use]
    pub fn is_directory(&self) -> bool {
        matches!(self, Self::Directory(_))
    }

    /// Returns `true` if this is a symlink entry.
    #[must_use]
    pub fn is_symlink(&self) -> bool {
        matches!(self, Self::Symlink(_))
    }

    /// Returns the file entry if this is a file, or `None` otherwise.
    #[must_use]
    pub fn as_file(&self) -> Option<&FileEntry<'a>> {
        match self {
            Self::File(f) => Some(f),
            _ => None,
        }
    }

    /// Returns the directory entry if this is a directory, or `None` otherwise.
    #[must_use]
    pub fn as_directory(&self) -> Option<&DirEntry<'a>> {
        match self {
            Self::Directory(d) => Some(d),
            _ => None,
        }
    }

    /// Returns the symlink entry if this is a symlink, or `None` otherwise.
    #[must_use]
    pub fn as_symlink(&self) -> Option<&SymlinkEntry<'a>> {
        match self {
            Self::Symlink(s) => Some(s),
            _ => None,
        }
    }

    /// Converts into a file entry if this is a file, or `None` otherwise.
    #[must_use]
    pub fn into_file(self) -> Option<FileEntry<'a>> {
        match self {
            Self::File(f) => Some(f),
            _ => None,
        }
    }

    /// Converts into a directory entry if this is a directory, or `None` otherwise.
    #[must_use]
    pub fn into_directory(self) -> Option<DirEntry<'a>> {
        match self {
            Self::Directory(d) => Some(d),
            _ => None,
        }
    }

    /// Converts into a symlink entry if this is a symlink, or `None` otherwise.
    #[must_use]
    pub fn into_symlink(self) -> Option<SymlinkEntry<'a>> {
        match self {
            Self::Symlink(s) => Some(s),
            _ => None,
        }
    }
}

impl<'a> From<FileEntry<'a>> for Entry<'a> {
    fn from(entry: FileEntry<'a>) -> Self {
        Self::File(entry)
    }
}

impl<'a> From<DirEntry<'a>> for Entry<'a> {
    fn from(entry: DirEntry<'a>) -> Self {
        Self::Directory(entry)
    }
}

impl<'a> From<SymlinkEntry<'a>> for Entry<'a> {
    fn from(entry: SymlinkEntry<'a>) -> Self {
        Self::Symlink(entry)
    }
}