Struct cpe::uri::Uri

pub struct Uri<'a> { /* private fields */ }

A CPE 2.2 URI

Note: field access is limited to ensure values only contain semantically valid components. Fields can be accessed through the “getter” methods, or through the Cpe methods, although the former is preferred with a Cpe as opposed to an OwnedCpe.

Display is implemented to show the decoded contents by default, or to re-encode the components when # is used to specify an alternate.

 use cpe::uri::Uri;
 let uri = Uri::builder()
           .part("a")
           .vendor("foo%21")
           .validate()
           .unwrap();

 assert_eq!(format!("{}", uri), "cpe:/a:foo!:*:*:*:*:*".to_owned());
 assert_eq!(format!("{:#}", uri), "cpe:/a:foo%21:*:*:*:*:*".to_owned());

Additionally, the 0 for zero-padding integers can be used to omit default “*” fields.

 use cpe::uri::Uri;
 let uri = Uri::builder()
           .part("a")
           .vendor("foo%21")
           .validate()
           .unwrap();

 assert_eq!(format!("{:0}", uri), "cpe:/a:foo!".to_owned());
 assert_eq!(format!("{:#0}", uri), "cpe:/a:foo%21".to_owned());

Implementations

impl<'a> Uri<'a>

pub fn new() -> Self

Create a new Uri with default values of ANY for each attribute.

pub fn builder() -> CpeBuilder<'a, Uri<'a>>

Create a CpeBuilder struct to construct a new Wfn.

use cpe::uri::Uri;

let cpe: Uri = Uri::builder()
              .part("a")
              .vendor("rust")
              .product("cargo")
              .validate()
              .unwrap();

println!("{:?}", cpe);

pub fn set_part(&mut self, part: &'a str) -> Result<()>

Set the CPE type part, a, o, h, or *.

The provided string slice will be parsed to its semantic meaning.

pub fn set_vendor(&mut self, vendor: &'a str) -> Result<()>

Set the CPE vendor.

The provided string slice will be parsed to its semantic meaning.

pub fn set_product(&mut self, product: &'a str) -> Result<()>

Set the CPE product.

The provided string slice will be parsed to its semantic meaning.

pub fn set_version(&mut self, version: &'a str) -> Result<()>

Set the CPE product.

The provided string will be parsed to its semantic meaning.

pub fn set_update(&mut self, update: &'a str) -> Result<()>

Set the CPE update.

The provided string will be parsed to its semantic meaning.

pub fn set_edition(&mut self, edition: &'a str) -> Result<()>

Set the CPE edition.

The provided string will be parsed to its semantic meaning. Note that this funciton will unpack a packed ~ delimited edition component if applicable.

pub fn set_language(&mut self, language: &'a str) -> Result<()>

Set the CPE language.

The provided string will be parsed to its semantic meaning. language must be a valid RFC-5646 language tag.

pub fn to_owned(&self) -> OwnedUri

Create an Owned copy of this CPE URI.

pub fn as_uri(&self) -> Wfn<'a>

Create a Wfn, perserving lifetimes of the original input. Note that strings may be cloned if the input was decoded.

pub fn parse(uri: &'a str) -> Result<Self>

Parse a CPE URI string.

This function will decode percent encodings and special characters to their semantic meaning.

Trait Implementations

impl<'a> Clone for Uri<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Cpe for Uri<'_>

fn part(&self) -> CpeType

fn vendor(&self) -> Component<'_>

fn product(&self) -> Component<'_>

fn version(&self) -> Component<'_>

fn update(&self) -> Component<'_>

fn edition(&self) -> Component<'_>

fn language(&self) -> &Language

fn sw_edition(&self) -> Component<'_>

fn target_sw(&self) -> Component<'_>

fn target_hw(&self) -> Component<'_>

fn other(&self) -> Component<'_>

impl<'a> Debug for Uri<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Uri<'a>

fn default() -> Uri<'a>

Returns the “default value” for a type.

impl Display for Uri<'_>

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

Formats the value using the given formatter.

impl From<&Uri<'_>> for OwnedUri

fn from(cpe: &Uri<'_>) -> Self

Converts to this type from the input type.

impl From<&Uri<'_>> for OwnedWfn

fn from(cpe: &Uri<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<&Uri<'a>> for Wfn<'a>

fn from(uri: &Uri<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<&Wfn<'a>> for Uri<'a>

fn from(wfn: &Wfn<'a>) -> Self

Converts to this type from the input type.

impl From<Uri<'_>> for OwnedUri

fn from(cpe: Uri<'_>) -> Self

Converts to this type from the input type.

impl From<Uri<'_>> for OwnedWfn

fn from(cpe: Uri<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<Uri<'a>> for Wfn<'a>

fn from(uri: Uri<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Wfn<'a>> for Uri<'a>

fn from(wfn: Wfn<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for Uri<'a>

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<'a> PartialEq for Uri<'a>

fn eq(&self, other: &Uri<'a>) -> 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<'a> Eq for Uri<'a>

impl<'a> StructuralPartialEq for Uri<'a>