Enum License

pub enum License {
    Spdx(Box<Expression>),
    Unknown(String),
}

Represents a license expression that can be either a valid SPDX identifier or a non-standard one.

Examples

use std::str::FromStr;

use alpm_types::License;

// Create License from a valid SPDX identifier
let license = License::from_str("MIT")?;
assert!(license.is_spdx());
assert_eq!(license.to_string(), "MIT");

// Create License from an invalid/non-SPDX identifier
let license = License::from_str("My-Custom-License")?;
assert!(!license.is_spdx());
assert_eq!(license.to_string(), "My-Custom-License");

Variants

Spdx(Box<Expression>)

A valid SPDX license expression

This variant is boxed to avoid large allocations

Unknown(String)

A non-standard license identifier

Implementations

impl License

pub fn new(license: String) -> Result<Self, Error>

Creates a new license

This function accepts both SPDX and non-standard identifiers and it is the same as as calling License::from_str

pub fn from_valid_spdx(identifier: String) -> Result<Self, Error>

Creates a new license from a valid SPDX identifier

Examples

use alpm_types::{Error, License};

let license = License::from_valid_spdx("Apache-2.0".to_string())?;
assert!(license.is_spdx());
assert_eq!(license.to_string(), "Apache-2.0");

assert!(License::from_valid_spdx("GPL-0.0".to_string()).is_err());
assert!(License::from_valid_spdx("Custom-License".to_string()).is_err());

assert_eq!(
    License::from_valid_spdx("GPL-2.0".to_string()),
    Err(Error::DeprecatedLicense("GPL-2.0".to_string()))
);

Errors

Returns an error if the given input cannot be parsed or is a deprecated license.

pub fn is_spdx(&self) -> bool

Returns true if the license is a valid SPDX identifier

Trait Implementations

impl Clone for License

fn clone(&self) -> License

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for License

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for License

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Custom serde serialization as Spdx doesn’t provide a serde Deserialize implementation. This implements deserialization from a string type.

Attempt to parse the given input as an [spdx::Expression] and to return a License::Spdx. If that fails, treat it as a License::Unknown that contains the original string.

impl Display for License

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

Formats the value using the given formatter.

impl FromStr for License

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

Creates a new License instance from a string slice.

If the input is a valid SPDX license expression, it will be marked as such; otherwise, it will be treated as a non-standard license identifier.

Examples

use std::str::FromStr;

use alpm_types::License;

let license = License::from_str("Apache-2.0")?;
assert!(license.is_spdx());
assert_eq!(license.to_string(), "Apache-2.0");

let license = License::from_str("NonStandard-License")?;
assert!(!license.is_spdx());
assert_eq!(license.to_string(), "NonStandard-License");

Errors

Returns an error if the given input is a deprecated SPDX license.

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for License

fn eq(&self, other: &License) -> 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 License

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Custom serde serialization as Spdx doesn’t provide a serde Serialize implementation.

impl StructuralPartialEq for License