Enum Tag

#[non_exhaustive]
#[repr(u8)]
pub enum Tag {
    Manifest = 1,
    Index = 2,
    Atoms = 3,
    Volume = 4,
    ChecksumNone = 20,
    ChecksumSha256 = 21,
    SignatureNone = 22,
    Directory = 30,
    File = 31,
}

Available on crate feature v2 only.

Unique identifiers used to indicate various components of a WEBC file.

Top-Level Sections

In general, all top-level sections are Type-Length-Value encoded.

• Tag (u8)
• Length (u64 LE)
• Value (Length bytes)

Versioning

Besides acting as an identifier for various elements in a WEBC file, the Tag plays an important part in versioning. An item’s layout is tied to its Tag, so any time the layout is changed, a new unique Tag should be created.

For example, if the format for a volume needs to be changed, a new Tag::VolumeV2 variant would be added instead of modifying the spec for existing volumes. Future reader implementations then need to handle Tag::Volume and Tag::VolumeV2 gracefully.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Manifest = 1

The manifest section, containing a CBOR-serialized crate::metadata::Manifest.

Index = 2

The index section, containing a CBOR-serialized crate::v2::Index.

The index section is laid out as follows:

• Tag::Index
• overall section length (u64 LE)
• CBOR data
• padding

Note to Implementors

This section may contain trailing padding bytes that should be ignored when deserializing the index.

Depending on the writer implementation, padding bytes may be necessary because the crate::v2::Index needs to be at the start of a WEBC file, yet it can only be calculated after everything has been serialized.

Atoms = 3

The atoms section.

An atoms section is laid out similar to Tag::Volume.

• Tag::Atoms
• overall section length (u64 LE)
• volume header length (u64 LE)
• volume header
• volume data length (u64 LE)
• volume data

Volume = 4

The volume section.

A volume section is laid out similar to Tag::Atoms.

• Tag::Volume
• overall section length
• volume name length (u64 LE)
• volume name (u64 LE)
• volume header length (u64 LE)
• volume header
• volume data length (u64 LE)
• volume data

ChecksumNone = 20

A tag for the empty checksum (i.e. crate::v2::Checksum::none()).

ChecksumSha256 = 21

A tag indicating that the crate::v2::Checksum is calculated using the SHA-256 hash of a section’s contents.

See also, crate::v2::Checksum::sha256().

SignatureNone = 22

A tag for the empty signature (i.e. crate::v2::Signature::none()).

Directory = 30

Metadata for a directory in the Tag::Volume header.

Each directory follows the type-length-value format.

• Tag::Directory
• overall directory length (u64 LE)
• zero or more entries

Where each entry is

• offset of the entry relative to the start of the header (u64 LE)
• name length (u64 LE)
• name (arbitrary number of bytes)

File = 31

Metadata for a file in the Tag::Volume header.

File metadata follows the following format:

• Tag::File
• start offset in data section (u64 LE)
• end offset in data section (u64 LE)
• SHA256 checksum (32 bytes)

Implementations

impl Tag

pub const ALL: [Tag; 9] = _

Get an iterator over all the tag variants.

pub const fn from_u8(tag: u8) -> Option<Self>

Try to load a Tag from its u8 representation.

pub const fn as_u8(self) -> u8

Get the Tag’s u8 representation.

pub const fn name(self) -> &'static str

Get the Tag’s human-friendly name.

pub fn display(maybe_tag: u8) -> impl Display

Gets a displayable implementation for something that may or may not be a known tag.

Unknown tags are printed in their hexadecimal representation.

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tag

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Tag

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

Formats the value using the given formatter.

impl Hash for Tag

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for Tag

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

Formats the value using the given formatter.

impl PartialEq<Tag> for u8

fn eq(&self, other: &Tag) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u8> for Tag

fn eq(&self, other: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Tag

fn eq(&self, other: &Tag) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Tag

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UpperHex for Tag

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

Formats the value using the given formatter.

impl Copy for Tag

impl Eq for Tag

impl StructuralPartialEq for Tag