Enum NodeType

#[repr(u8)]
pub enum NodeType {
    Content = 0,
    Directory = 1,
    Origin = 2,
    Release = 3,
    Revision = 4,
    Snapshot = 5,
}

Object type of an SWHID

Reference

• https://docs.softwareheritage.org/devel/swh-model/data-model.html

Variants

Content = 0

Directory = 1

a list of named directory entries, each of which pointing to other artifacts, usually file contents or sub-directories. Directory entries are also associated to some metadata stored as permission bits.

Origin = 2

code “hosting places” as previously described are usually large platforms that host several unrelated software projects. For software provenance purposes it is important to be more specific than that.

Software origins are fine grained references to where source code artifacts archived by Software Heritage have been retrieved from. They take the form of (type, url) pairs, where url is a canonical URL (e.g., the address at which one can git clone a repository or download a source tarball) and type the kind of software origin (e.g., git, svn, or dsc for Debian source packages).

Release = 3

AKA “tags”

some revisions are more equals than others and get selected by developers as denoting important project milestones known as “releases”. Each release points to the last commit in project history corresponding to the release and carries metadata: release name and version, release message, cryptographic signatures, etc.

Revision = 4

AKA commits

Software development within a specific project is essentially a time-indexed series of copies of a single “root” directory that contains the entire project source code. Software evolves when a d eveloper modifies the content of one or more files in that directory and record their changes.

Each recorded copy of the root directory is known as a “revision”. It points to a fully-determined directory and is equipped with arbitrary metadata. Some of those are added manually by the developer (e.g., commit message), others are automatically synthesized (timestamps, preceding commit(s), etc).

Snapshot = 5

any kind of software origin offers multiple pointers to the “current” state of a development project. In the case of VCS this is reflected by branches (e.g., master, development, but also so called feature branches dedicated to extending the software in a specific direction); in the case of package distributions by notions such as suites that correspond to different maturity levels of individual packages (e.g., stable, development, etc.).

A “snapshot” of a given software origin records all entry points found there and where each of them was pointing at the time. For example, a snapshot object might track the commit where the master branch was pointing to at any given time, as well as the most recent release of a given package in the stable suite of a FOSS distribution.

Implementations

impl NodeType

pub const NUMBER_OF_TYPES: usize = 6usize

Get the number of possible types.

To avoid having to update this when adding a new type we can use the unstable function std::mem::variant_count or the variant_count crate. But for now we just hardcode it while we decide how to deal with this.

pub const BITWIDTH: usize = 3usize

The number of bits needed to store the node type as integers This is ceil(log2(NUMBER_OF_TYPES)) which can be arithmetized into floor(log2(NUMBER_OF_TYPES)) plus one if it’s not a power of two.

pub fn to_str(&self) -> &'static str

Convert a type to the str used in the SWHID

pub fn to_u8(&self) -> u8

Convert a type to its enum discriminant value.

In all cases using this method is both safer and more concise than (node_type as isize).try_into().unwrap().

pub fn all() -> Vec<Self>

Returns a vector containing all possible NodeType values.

Trait Implementations

impl Clone for NodeType

fn clone(&self) -> NodeType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeType

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

Formats the value using the given formatter.

impl Display for NodeType

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

Formats the value using the given formatter.

impl FromStr for NodeType

fn from_str(s: &str) -> Result<Self, Self::Err>

Examples

assert_eq!("dir".parse::<NodeType>(), Ok(NodeType::Directory));
assert!(matches!("xyz".parse::<NodeType>(), Err(_)));

type Err = String

The associated error which can be returned from parsing.

impl Hash for NodeType

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 PartialEq for NodeType

fn eq(&self, other: &NodeType) -> 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<'a> TryFrom<&'a [u8]> for NodeType

type Error = &'a [u8]

The type returned in the event of a conversion error.

fn try_from(value: &'a [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for NodeType

type Error = u8

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for NodeType

impl Eq for NodeType

impl StructuralPartialEq for NodeType