Struct Relation 

pub struct Relation(/* private fields */);

A node in the syntax tree representing a $ast

Implementations

impl Relation

pub fn syntax(&self) -> &SyntaxNode<Lang>

Access the underlying syntax node.

impl Relation

pub fn new( name: &str, version_constraint: Option<(VersionConstraint, Version)>, ) -> Self

Create a new relation

Arguments

• name - The name of the package
• version_constraint - The version constraint and version to use

Example

use debian_control::lossless::relations::{Relation};
use debian_control::relations::VersionConstraint;
let relation = Relation::new("samba", Some((VersionConstraint::GreaterThanEqual, "2.0".parse().unwrap())));
assert_eq!(relation.to_string(), "samba (>= 2.0)");

pub fn wrap_and_sort(&self) -> Self

Wrap and sort this relation

Example

use debian_control::lossless::relations::Relation;
let relation = "  samba  (  >= 2.0) ".parse::<Relation>().unwrap();
assert_eq!(relation.wrap_and_sort().to_string(), "samba (>= 2.0)");

pub fn simple(name: &str) -> Self

Create a new simple relation, without any version constraints.

Example

use debian_control::lossless::relations::Relation;
let relation = Relation::simple("samba");
assert_eq!(relation.to_string(), "samba");

pub fn drop_constraint(&mut self) -> bool

Remove the version constraint from the relation.

Example

use debian_control::lossless::relations::{Relation};
use debian_control::relations::VersionConstraint;
let mut relation = Relation::new("samba", Some((VersionConstraint::GreaterThanEqual, "2.0".parse().unwrap())));
relation.drop_constraint();
assert_eq!(relation.to_string(), "samba");

pub fn try_name(&self) -> Option<String>

Return the name of the package in the relation, if present.

Returns None for malformed relations that lack a package name (e.g. when substvars are parsed without substvar support).

Example

use debian_control::lossless::relations::Relation;
let relation = Relation::simple("samba");
assert_eq!(relation.try_name(), Some("samba".to_string()));

pub fn name_range(&self) -> Option<TextRange>

Return the text range of the package-name token, if present.

Useful for editor tooling that wants to highlight or attach metadata to the package name itself, separate from any version constraint or architecture qualifier.

Example

use debian_control::lossless::relations::Relation;
let relation: Relation = "samba (>= 4.0)".parse().unwrap();
let range = relation.name_range().unwrap();
assert_eq!(&relation.to_string()[range], "samba");

pub fn name(&self) -> String

👎Deprecated since 0.3.6:

Use try_name() instead, which returns Option<String>

Return the name of the package in the relation.

Panics

Panics if the relation has no package name (e.g. malformed input). Prefer try_name for potentially malformed relations.

Example

use debian_control::lossless::relations::Relation;
let relation = Relation::simple("samba");
assert_eq!(relation.name(), "samba");

pub fn archqual(&self) -> Option<String>

Return the archqual

Example

use debian_control::lossless::relations::Relation;
let relation: Relation = "samba:any".parse().unwrap();
assert_eq!(relation.archqual(), Some("any".to_string()));

pub fn set_archqual(&mut self, archqual: &str)

Set the architecture qualifier for this relation.

Example

use debian_control::lossless::relations::Relation;
let mut relation = Relation::simple("samba");
relation.set_archqual("any");
assert_eq!(relation.to_string(), "samba:any");

pub fn version(&self) -> Option<(VersionConstraint, Version)>

Return the version constraint and the version it is constrained to.

pub fn set_version( &mut self, version_constraint: Option<(VersionConstraint, Version)>, )

Set the version constraint for this relation

Example

use debian_control::lossless::relations::{Relation};
use debian_control::relations::VersionConstraint;
let mut relation = Relation::simple("samba");
relation.set_version(Some((VersionConstraint::GreaterThanEqual, "2.0".parse().unwrap())));
assert_eq!(relation.to_string(), "samba (>= 2.0)");

pub fn architectures(&self) -> Option<impl Iterator<Item = String> + '_>

Return an iterator over the architectures for this relation

Example

use debian_control::lossless::relations::Relation;
let relation: Relation = "samba [amd64]".parse().unwrap();
assert_eq!(relation.architectures().unwrap().collect::<Vec<_>>(), vec!["amd64".to_string()]);

pub fn profiles(&self) -> impl Iterator<Item = Vec<BuildProfile>> + '_

Returns an iterator over the build profiles for this relation

Example

use debian_control::lossless::relations::{Relation};
use debian_control::relations::{BuildProfile};
let relation: Relation = "samba <!nocheck>".parse().unwrap();
assert_eq!(relation.profiles().collect::<Vec<_>>(), vec![vec![BuildProfile::Disabled("nocheck".to_string())]]);

pub fn profile_ranges(&self) -> impl Iterator<Item = TextRange> + '_

Return an iterator over the text ranges of each build-profile name token (the IDENT inside <...> groups).

Useful for tooling that wants to highlight, hover over, or navigate from a specific profile name. The leading ! of disabled profiles is not included.

Example

use debian_control::lossless::relations::Relation;
let relation: Relation = "samba <!nocheck>".parse().unwrap();
let ranges: Vec<_> = relation.profile_ranges().collect();
assert_eq!(ranges.len(), 1);
let r = ranges[0];
assert_eq!(&relation.to_string()[r], "nocheck");

pub fn remove(&mut self)

Remove this relation

Example

use debian_control::lossless::relations::{Relation,Entry};
let mut entry: Entry = r"python3-dulwich (>= 0.19.0) | python3-urllib3 (<< 1.26.0)".parse().unwrap();
let mut relation = entry.get_relation(0).unwrap();
relation.remove();
assert_eq!(entry.to_string(), "python3-urllib3 (<< 1.26.0)");

pub fn set_architectures<'a>( &mut self, architectures: impl Iterator<Item = &'a str>, )

Set the architectures for this relation

Example

use debian_control::lossless::relations::Relation;
let mut relation = Relation::simple("samba");
relation.set_architectures(vec!["amd64", "i386"].into_iter());
assert_eq!(relation.to_string(), "samba [amd64 i386]");

pub fn add_profile(&mut self, profile: &[BuildProfile])

Add a build profile to this relation

Example

use debian_control::lossless::relations::Relation;
use debian_control::relations::BuildProfile;
let mut relation = Relation::simple("samba");
relation.add_profile(&[BuildProfile::Disabled("nocheck".to_string())]);
assert_eq!(relation.to_string(), "samba <!nocheck>");

pub fn build(name: &str) -> RelationBuilder

Build a new relation

pub fn is_implied_by(&self, outer: &Relation) -> bool

Check if this relation is implied by another relation.

A relation is implied by another if the outer relation is more restrictive or equal to this relation. For example:

• pkg >= 1.0 is implied by pkg >= 1.5 (outer is more restrictive)
• pkg >= 1.0 is implied by pkg = 1.5 (outer is more restrictive)
• pkg (no version) is implied by any versioned constraint on pkg

Arguments

• outer - The outer relation that may imply this relation

Returns

true if this relation is implied by outer, false otherwise

Example

use debian_control::lossless::relations::Relation;
use debian_control::relations::VersionConstraint;

let inner = Relation::new("pkg", Some((VersionConstraint::GreaterThanEqual, "1.0".parse().unwrap())));
let outer = Relation::new("pkg", Some((VersionConstraint::GreaterThanEqual, "1.5".parse().unwrap())));
assert!(inner.is_implied_by(&outer));

let inner2 = Relation::new("pkg", None);
assert!(inner2.is_implied_by(&outer));

Trait Implementations

impl Debug for Relation

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

Formats the value using the given formatter.

impl Display for Relation

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

Formats the value using the given formatter.

impl Eq for Relation

impl From<Relation> for Entry

fn from(relation: Relation) -> Self

Converts to this type from the input type.

impl From<Relation> for Relation

fn from(relation: Relation) -> Self

Converts to this type from the input type.

impl From<Relation> for Relation

fn from(relation: Relation) -> Self

Converts to this type from the input type.

impl FromStr for Relation

type Err = String

The associated error which can be returned from parsing.

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

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

impl Ord for Relation

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Relation

fn eq(&self, other: &Self) -> 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 PartialOrd for Relation

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.