Struct Licensing 

pub struct Licensing<'a> {
    pub expression: Option<&'a str>,
    pub ids: &'a BTreeSet<String>,
}

the licensing a component declares.

carries the SPDX expression when the source document had one, so AND/OR and WITH survive; otherwise it falls back to the flattened identifier set, which is read as a conjunction (every identifier applies).

Fields

expression: Option<&'a str>

the declared SPDX expression, if any.

ids: &'a BTreeSet<String>

the flattened license identifiers.

Implementations

impl<'a> Licensing<'a>

pub fn from_ids(ids: &'a BTreeSet<String>) -> Self

builds a licensing view from a flat identifier set.

pub fn satisfiable<F>(&self, acceptable: F) -> bool

where F: FnMut(&LicenseRequirement) -> bool,

reports whether the licensing can be satisfied by taking on only requirements acceptable approves of.

OR lets the consumer pick one side, AND demands both. an expression that fails to parse, or an absent expression, falls back to requiring every identifier in the flat set.

Example

use sbom_model::Licensing;
use std::collections::BTreeSet;

let ids: BTreeSet<String> = ["Apache-2.0".into(), "MIT".into()].into();
let choice = Licensing { expression: Some("MIT OR Apache-2.0"), ids: &ids };
assert!(choice.satisfiable(|r| r.license == "MIT"));

let both = Licensing { expression: Some("MIT AND Apache-2.0"), ids: &ids };
assert!(!both.satisfiable(|r| r.license == "MIT"));

pub fn requirements(&self) -> BTreeSet<LicenseRequirement>

returns every requirement the licensing mentions, whether or not a consumer must accept it.

Trait Implementations

impl<'a> Clone for Licensing<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Licensing<'a>

impl<'a> Debug for Licensing<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Licensing<'a>

impl<'a> PartialEq for Licensing<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Licensing<'a>