Struct SetVersion

pub struct SetVersion { /* private fields */ }

A SetVer version specification.

Implementation details

This struct is implemented using HashSet from the standard library. Therefore, it is not usable in no-std environments right now.

Implementations

impl SetVersion

pub fn setver_compare(&self, other: &SetVersion) -> f32

Implements the SetVer comparison function, as per the specification.

The only returned values are 0, 1, Infinity and NaN.

pub fn is_subset(&self, other: &SetVersion) -> bool

Returns whether this SetVer version is a subset of the other version, according to standard set laws.

use setver::SetVersion;
let first_version: SetVersion = "{}".parse().unwrap();
let second_version: SetVersion = "{{}}".parse().unwrap();
assert!(first_version.is_subset(&second_version));

pub fn is_strict_subset(&self, other: &SetVersion) -> bool

Returns whether this SetVer version is a strict subset of the other version, according to standard set laws.

pub fn is_superset(&self, other: &SetVersion) -> bool

Returns whether this SetVer version is a superset of the other version, according to standard set laws.

pub fn is_strict_superset(&self, other: &SetVersion) -> bool

Returns whether this SetVer version is a strict superset of the other version, according to standard set laws.

pub fn add_child_version(&mut self, child: Rc<SetVersion>) -> &mut Self

Adds the given version as a child version. This is useful when constructing a parent version for one or many previous child versions.

Examples found in repository

examples/number_to_setver.rs (line 20)

fn main() {
	let mut args = args();
	args.next();

	if let Some(number_str) = args.next() {
		let number = number_str.trim().parse::<usize>().expect("version is not an integer");

		// This is exactly how natural numbers (including zero) work in set theory.
		// Some dynamic programming makes this ~ 1/2 O(n^2).
		let mut previous_number_setvers = Vec::with_capacity(number);
		previous_number_setvers.push(Rc::new(SetVersion::default()));

		for n in 1..=number {
			let mut n_version = SetVersion::default();
			for i in 0..n {
				n_version.add_child_version(previous_number_setvers[i].clone());
			}
			previous_number_setvers.push(Rc::new(n_version));
		}

		let number_version = previous_number_setvers.last().unwrap();
		println!("{}", number_version);
	} else {
		eprintln!("usage: number_to_setver NUMBER");
	}
}

pub fn to_integralternative(&self) -> u128

Implements the Integralternative. This is the same as converting a SetVersion into an u128.

Panics

For obvious reasons (if you know how the integralternative works), SetVersions with more than 128 braces in their text representation cannot be stored in a u128. In this case, this function will panic. Use to_integralternative_bytes instead.

Examples found in repository

examples/alternative_representations.rs (line 27)

fn main() {
	let mut args = args();
	args.next();
	if let Some(mut version) = args.next() {
		if &version == "-" {
			version = String::new();
			std::io::stdin().read_line(&mut version).expect("couldn't read setver from stdin");
			version = version.trim().to_owned();
		}

		let canonicalized = version.parse::<SetVersion>().expect("invalid setver version");
		let canonicalized_str = canonicalized.to_string();
		let original_width = version.len().max("direct".len());
		let canonical_width = canonicalized_str.len().max("canonicalized".len());
		println!(
			"                    {:>original_width$} {:>canonical_width$}
set representation  {:>original_width$} {:>canonical_width$}
integralternative   {:>original_width$} {:>canonical_width$}",
			"direct",
			"canonicalized",
			version,
			canonicalized_str,
			SetVersion::string_to_integralternative(&version),
			canonicalized.to_integralternative(),
			original_width = original_width,
			canonical_width = canonical_width
		);
	} else {
		eprintln!("usage: alternative_representations SETVER_VERSION");
	}
}

pub fn string_to_integralternative(setver: &str) -> u128

Implements the Integralternative and operates on a string. This is convenient if the canonicalized form of the given setver spec is different from the string.

Panics

For obvious reasons (if you know how the integralternative works), SetVersions with more than 128 braces in their text representation cannot be stored in a u128. In this case, this function will panic. Use to_integralternative_bytes instead.

Examples found in repository

examples/alternative_representations.rs (line 26)

fn main() {
	let mut args = args();
	args.next();
	if let Some(mut version) = args.next() {
		if &version == "-" {
			version = String::new();
			std::io::stdin().read_line(&mut version).expect("couldn't read setver from stdin");
			version = version.trim().to_owned();
		}

		let canonicalized = version.parse::<SetVersion>().expect("invalid setver version");
		let canonicalized_str = canonicalized.to_string();
		let original_width = version.len().max("direct".len());
		let canonical_width = canonicalized_str.len().max("canonicalized".len());
		println!(
			"                    {:>original_width$} {:>canonical_width$}
set representation  {:>original_width$} {:>canonical_width$}
integralternative   {:>original_width$} {:>canonical_width$}",
			"direct",
			"canonicalized",
			version,
			canonicalized_str,
			SetVersion::string_to_integralternative(&version),
			canonicalized.to_integralternative(),
			original_width = original_width,
			canonical_width = canonical_width
		);
	} else {
		eprintln!("usage: alternative_representations SETVER_VERSION");
	}
}

pub fn to_integralternative_bytes(&self) -> Vec<u8>

Implements the Integralternative. The return value is not as practical as the one of to_integralternative, but it can always represent the integralternative and will never panic.

The returned bytes are in LSB-first order (little-endian).

pub fn string_to_integralternative_bytes(setver: &str) -> Vec<u8>

Implements the Integralternative but operates directly on a string. This is convenient if the canonicalized form of the given setver spec is different from the string. The return value is not as practical as the one of to_integralternative, but it can always represent the integralternative and will never panic.

The returned bytes are in LSB-first order (little-endian).

Trait Implementations

impl Clone for SetVersion

fn clone(&self) -> SetVersion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SetVersion

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

Formats the value using the given formatter.

impl Default for SetVersion

fn default() -> SetVersion

Returns the “default value” for a type.

impl Display for SetVersion

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

The stringified version is always in canonical form, meaning that small sets are printed first.

impl From<&SetVersion> for String

fn from(this: &SetVersion) -> Self

Converts to this type from the input type.

impl From<&SetVersion> for u128

fn from(this: &SetVersion) -> Self

Converts to this type from the input type.

impl FromStr for SetVersion

type Err = SetVerParseError

The associated error which can be returned from parsing.

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

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

impl Ord for SetVersion

fn cmp(&self, other: &SetVersion) -> 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<&str> for SetVersion

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

Checks whether the string parses to the same setver. If the string is not a setver version, they are not equal.

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 PartialEq<u128> for SetVersion

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

Checks whether the integer is the canonical integralternative of this setver.

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 PartialEq for SetVersion

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

fn partial_cmp(&self, other: &SetVersion) -> 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.

impl Eq for SetVersion

impl StructuralPartialEq for SetVersion