Struct spdx_rs::models::SimpleExpression

pub struct SimpleExpression {
    pub identifier: String,
    pub document_ref: Option<String>,
    pub license_ref: bool,
}

Simple SPDX license expression.

Fields

identifier: String

The license identifier.

document_ref: Option<String>

Optional DocumentRef for the expression.

license_ref: bool

true if the expression is a user defined license reference.

Implementations

impl SimpleExpression

pub const fn new( identifier: String, document_ref: Option<String>, license_ref: bool ) -> SimpleExpression

Create a new simple expression.

pub fn parse(expression: &str) -> Result<SimpleExpression, SpdxExpressionError>

Parse a simple expression.

Examples

let expression = SimpleExpression::parse("MIT")?;

The function will only accept simple expressions, compound expressions will fail.

let expression = SimpleExpression::parse("MIT OR ISC");
assert!(expression.is_err());

Errors

Fails if parsing fails.

Trait Implementations

impl Clone for SimpleExpression

fn clone(&self) -> SimpleExpression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleExpression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SimpleExpression

fn deserialize<D>( deserializer: D ) -> Result<SimpleExpression, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SimpleExpression

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

Formats the value using the given formatter.

impl Hash for SimpleExpression

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

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<SimpleExpression> for SimpleExpression

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for SimpleExpression

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

Serialize this value into the given Serde serializer.

impl Eq for SimpleExpression

impl StructuralEq for SimpleExpression

impl StructuralPartialEq for SimpleExpression