Enum License 

pub enum License {
    Name(String),
    Text(String),
    Named(String, String),
}

A license, which can be just a name, a text or a named license.

Variants

Name(String)

A license with just a name.

Text(String)

A license with just a text.

Named(String, String)

A license with a name and a text.

Implementations

impl License

pub fn name(&self) -> Option<&str>

Returns the name of the license, if any.

Note that this may be a license expression containing multiple licenses combined with or, and, or with. Use License::expr to parse the expression into a structured LicenseExpr.

Examples found in repository

examples/license-for-file.rs (line 27)

pub fn main() {
    let c = TEXT.parse::<Copyright>().unwrap();
    let license = c.find_license_for_file(Path::new("debian/foo")).unwrap();
    println!("{}", license.name().unwrap());
}

pub fn text(&self) -> Option<&str>

Returns the text of the license, if any.

pub fn expr(&self) -> Option<LicenseExpr>

Parse the license name as a structured expression.

Returns None if the license has no name (i.e. is a Text variant).

Examples

use debian_copyright::{License, LicenseExpr};

let license = License::Name("GPL-2+ or MIT".to_string());
assert_eq!(
    license.expr(),
    Some(LicenseExpr::Or(vec![
        LicenseExpr::Name("GPL-2+".to_string()),
        LicenseExpr::Name("MIT".to_string()),
    ])),
);

Trait Implementations

impl Clone for License

fn clone(&self) -> License

Returns a duplicate 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 Display for License

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

Formats the value using the given formatter.

impl From<LicenseParagraph> for License

fn from(p: LicenseParagraph) -> Self

Converts to this type from the input type.

impl FromStr for License

type Err = String

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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 Eq for License

impl StructuralPartialEq for License