Struct Version

pub struct Version { /* private fields */ }

Implementations

impl Version

pub fn new(vector: Vec<u64>) -> Self

Create new instance from vector

Example

use version_operators::Version;

let vector = vec![1, 14, 3];

let version = Version::new(vector.clone());

assert_eq!(version.to_vector(), vector);

pub fn from_split_callback<F>(input: &str, callback: F) -> Self

where F: Fn(char) -> bool,

Create new instance using a custom spliter callback function or closure

Example with Closure

use version_operators::Version;

let version = Version::from_split_callback("1.14.3", |c: char| !c.is_numeric());

assert_eq!(version.to_vector(), vec![1, 14, 3]);

Example with Function

use version_operators::Version;

fn custom_spliter(c: char) -> bool {
    !c.is_numeric()
}

let version = Version::from_split_callback("1.14.3", &custom_spliter);

assert_eq!(version.to_vector(), vec![1, 14, 3]);

pub fn from_str(input: &str) -> Self

Convert &str to vector of unsigned-integers

Example

use version_operators::Version;

let version = Version::from_str("1.14.3");

assert_eq!(version.to_vector(), vec![1, 14, 3]);

Examples found in repository

examples/version-math.rs (line 26)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 3 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let left = Version::from_str(&version_args[0]);
            let operator: &str = &version_args[1].to_owned();
            let right = Version::from_str(&version_args[2]);
            let result = match operator {
                "+" | "-add" => left + right,
                "-" | "-sub" => left - right,
                _ => panic!("Unrecognized operator! Try '+'/'-add' or '-'/'-sub'"),
            };
            println!("{:?}", result.to_vector());
            version_args = vec![];
        }
    }
}

examples/version-increment.rs (line 18)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 2 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let mut version = Version::from_str(&version_args[0]);
            let position: &u8 = &version_args[1].to_owned()
                                                .parse::<u8>()
                                                .unwrap();

            let mut vector: Vec<u64> = vec![];
            for _ in 0..position.to_owned() {
                vector.push(0);
            }
            vector.push(1);
            println!("{:?}", vector);

            version += Version::from_vec(vector);
            println!("{:?}", version.to_vector());

            version_args = vec![];
        }
    }
}

examples/version-compare.rs (line 26)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 3 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let left = Version::from_str(&version_args[0]);
            let comparator: &str = &version_args[1].to_owned();
            let right = Version::from_str(&version_args[2]);
            let result = match comparator {
                "==" | "-eq" => left == right,
                "!=" | "-ne" => left != right,
                ">=" | "-ge" => left >= right,
                ">" | "-gt" => left > right,
                "<=" | "-le" => left <= right,
                "<" | "-lt" => left < right,
                _ => panic!("Unrecognized operator! Try '==' or '!=' or '-lt' or '-gt'"),
            };
            println!("{:?}", result);
            version_args = vec![];
        }
    }
}

pub fn from_vec(vector: Vec<u64>) -> Self

Save vector of unsigned-integers to new instance of Version

Example

use version_operators::Version;

let vector = vec![1, 14, 3];
let version = Version::from_vec(vector.clone());

assert_eq!(version.to_vector(), vector);

Examples found in repository

examples/version-increment.rs (line 30)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 2 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let mut version = Version::from_str(&version_args[0]);
            let position: &u8 = &version_args[1].to_owned()
                                                .parse::<u8>()
                                                .unwrap();

            let mut vector: Vec<u64> = vec![];
            for _ in 0..position.to_owned() {
                vector.push(0);
            }
            vector.push(1);
            println!("{:?}", vector);

            version += Version::from_vec(vector);
            println!("{:?}", version.to_vector());

            version_args = vec![];
        }
    }
}

pub fn to_vector(self) -> Vec<u64>

Passes ownership of vector within Version instance

Example

use version_operators::Version;

let version = Version::from_str("1.14.3");

assert_eq!(version.to_vector(), vec![1, 14, 3]);

Examples found in repository

examples/version-math.rs (line 34)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 3 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let left = Version::from_str(&version_args[0]);
            let operator: &str = &version_args[1].to_owned();
            let right = Version::from_str(&version_args[2]);
            let result = match operator {
                "+" | "-add" => left + right,
                "-" | "-sub" => left - right,
                _ => panic!("Unrecognized operator! Try '+'/'-add' or '-'/'-sub'"),
            };
            println!("{:?}", result.to_vector());
            version_args = vec![];
        }
    }
}

examples/version-increment.rs (line 31)

fn main() {
    let mut iter = env::args().skip(1);
    let mut version_args: Vec<String> = vec![];
    loop {
        if version_args.len() < 2 {
            let arg = iter.next();
            match arg {
                Some(value) => version_args.push(value),
                _ => break,
            }
        } else {
            let mut version = Version::from_str(&version_args[0]);
            let position: &u8 = &version_args[1].to_owned()
                                                .parse::<u8>()
                                                .unwrap();

            let mut vector: Vec<u64> = vec![];
            for _ in 0..position.to_owned() {
                vector.push(0);
            }
            vector.push(1);
            println!("{:?}", vector);

            version += Version::from_vec(vector);
            println!("{:?}", version.to_vector());

            version_args = vec![];
        }
    }
}

Trait Implementations

impl Add for Version

Implement addition (+) operator

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

Example

use version_operators::Version;

let version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14.2");

let version_new = version_one + version_two;

assert!(version_new.to_vector() == vec![2, 28, 5]);

type Output = Version

The resulting type after applying the + operator.

impl AddAssign for Version

Implement add assignment (+=) operator

fn add_assign(&mut self, other: Self)

Example

use version_operators::Version;

let mut version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14.2");

version_one += version_two;

assert!(version_one.to_vector() == vec![2, 28, 5]);

impl Clone for Version

fn clone(&self) -> Version

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Version

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

Formats the value using the given formatter.

impl Ord for Version

Implement greater/less-than (<, >) and operators

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

Example Greater Than

use version_operators::Version;

let version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14.2");

assert!(version_one > version_two);
assert_eq!(version_two > version_one, false);

Example Less Than

use version_operators::Version;

let version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14");

assert!(version_two < version_one);
assert_eq!(version_one < version_two, false);

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 Version

Implement equal/not-equal (==, !=) operators

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

Example Equality

use version_operators::Version;

let version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14.3");

assert!(version_one == version_two);
assert_eq!(version_one, version_two);

Example Inequality

use version_operators::Version;

let version_one = Version::from_str("1.14");
let version_two = Version::from_str("1.14.2");

assert!(version_one != version_two);
assert_ne!(version_one, version_two);

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 Version

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.

impl Sub for Version

Implement subtraction (-) operator

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

Example

use version_operators::Version;
 
let version_one = Version::from_str("1.14.3");
let version_two = Version::from_str("1.14.2");

let version_new = version_one - version_two;

assert!(version_new.to_vector() == vec![0, 0, 1]);

type Output = Version

The resulting type after applying the - operator.

impl SubAssign for Version

Implement subtract assignment (-=) operator

fn sub_assign(&mut self, other: Self)

Example

use version_operators::Version;

let mut version = Version::from_str("1.14.3");

version -= Version::from_str("1.14.2");

assert!(version.to_vector() == vec![0, 0, 1]);

impl Eq for Version

See: PartialEq implementation