Enum `Op`

enum Op

SemVer comparison operator: =, >, >=, <, <=, ~, ^, *.

Op::Exact

=I.J.K — exactly the version I.J.K
=I.J — equivalent to >=I.J.0, <I.(J+1).0
=I — equivalent to >=I.0.0, <(I+1).0.0

Op::Greater

>I.J.K
>I.J — equivalent to >=I.(J+1).0
>I — equivalent to >=(I+1).0.0

Op::GreaterEq

>=I.J.K
>=I.J — equivalent to >=I.J.0
>=I — equivalent to >=I.0.0

Op::Less

<I.J.K
<I.J — equivalent to <I.J.0
<I — equivalent to <I.0.0

Op::LessEq

<=I.J.K
<=I.J — equivalent to <I.(J+1).0
<=I — equivalent to <(I+1).0.0

Op::Tilde ("patch" updates)

Tilde requirements allow the patch part of the semver version (the third number) to increase.

~I.J.K — equivalent to >=I.J.K, <I.(J+1).0
~I.J — equivalent to =I.J
~I — equivalent to =I

Op::Caret ("compatible" updates)

Caret requirements allow parts that are right of the first nonzero part of the semver version to increase.

^I.J.K (for I>0) — equivalent to >=I.J.K, <(I+1).0.0
^0.J.K (for J>0) — equivalent to >=0.J.K, <0.(J+1).0
^0.0.K — equivalent to =0.0.K
^I.J (for I>0 or J>0) — equivalent to ^I.J.0
^0.0 — equivalent to =0.0
^I — equivalent to =I

Op::Wildcard

I.J.* — equivalent to =I.J
I.* or I.*.* — equivalent to =I

Variants

Exact
Greater
GreaterEq
Less
LessEq
Tilde
Caret
Wildcard

Implementations

`impl Clone for Op`

fn clone(self: &Self) -> Op

`impl Copy for Op`

`impl Debug for Op`

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

`impl Eq for Op`

`impl Freeze for Op`

`impl Hash for Op`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl PartialEq for Op`

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

`impl RefUnwindSafe for Op`

`impl Send for Op`

`impl StructuralPartialEq for Op`

`impl Sync for Op`

`impl Unpin for Op`

`impl UnwindSafe for Op`

`impl<T> Any for Op`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Op`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Op`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Op`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Op`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Op`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Op`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Op`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Op`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>