Struct webc::v1::FsEntry

pub struct FsEntry<'a> {
    pub fs_type: FsEntryType,
    pub text: Cow<'a, str>,
    pub offset_start: u64,
    pub offset_end: u64,
}

Directory or file entry, parsed without any allocation

Fields

fs_type: FsEntryType

If the FsEntryType == Dir, then offset_start..offset_end points to the start / end bytes of the next directory level, relative to the file header

If the FsEntryType = File, then offset_start..offset_end points to the actual file contents in the volume.data field

Inside of a directory level, all files are grouped by the name of the parent directory, at parsing time only the top-level directories are parsed

text: Cow<'a, str>

Directory / file name, for example usr, lib or var in "/usr/lib/var"

offset_start: u64

offset_end: u64

Implementations

impl<'a> FsEntry<'a>

pub fn get_len(&self) -> u64

Returns the length of the file in bytes (0 for directories)

pub fn calculate_byte_length(entries: &[Self]) -> usize

pub fn into_bytes(entries: &[Self]) -> Option<Vec<u8>>

Serializes a list of FsEntry into bytes (usually done to encode one directory level)

Binary format

[8 bytes]: size of the directory level itself

[
  [1 byte]:  file entry type (0 = Directory, 1 = File, .. ?)
  [7 bytes]: text length N (only 7 bytes long instead of 8, maximum file
             name length = 268435456 instead of 4294967296 bytes)
  [8 bytes]: offset_start
  [8 bytes]: offset_end
  [n bytes]: text (directory / file name)
]

pub fn parse(data: &'a [u8]) -> Vec<Self>

Reverse function of Self::into_bytes, parses one directory level from a set of bytes. One additional feature is that not more than n bytes are parsed if n is the size of the serialized directory level, even if the input buffer is larger than n.

If the directory level could not be parsed, the parsing is interrupted and the given file entries are returns as-is (no check for completeness)

Trait Implementations

impl<'a> Clone for FsEntry<'a>

fn clone(&self) -> FsEntry<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for FsEntry<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq<FsEntry<'a>> for FsEntry<'a>

fn eq(&self, other: &FsEntry<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for FsEntry<'a>

impl<'a> StructuralEq for FsEntry<'a>

impl<'a> StructuralPartialEq for FsEntry<'a>