Trait otter_api_tests::cmp::PartialOrd

#[lang = "partial_ord"]
pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where
    Rhs: ?Sized, {
    #[must_use]
    pub fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

    #[must_use]
    pub fn lt(&self, other: &Rhs) -> bool { ... }
    #[must_use]
    pub fn le(&self, other: &Rhs) -> bool { ... }
    #[must_use]
    pub fn gt(&self, other: &Rhs) -> bool { ... }
    #[must_use]
    pub fn ge(&self, other: &Rhs) -> bool { ... }
}

Trait for values that can be compared for a sort-order.

The comparison must satisfy, for all a, b and c:

• asymmetry: if a < b then !(a > b), as well as a > b implying !(a < b); and
• transitivity: a < b and b < c implies a < c. The same must hold for both == and >.

Note that these requirements mean that the trait itself must be implemented symmetrically and transitively: if T: PartialOrd<U> and U: PartialOrd<V> then U: PartialOrd<T> and T: PartialOrd<V>.

Derivable

This trait can be used with #[derive]. When derived on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct’s members. When derived on enums, variants are ordered by their top-to-bottom discriminant order.

How can I implement PartialOrd?

PartialOrd only requires implementation of the partial_cmp method, with the others generated from default implementations.

However it remains possible to implement the others separately for types which do not have a total order. For example, for floating point numbers, NaN < 0 == false and NaN >= 0 == false (cf. IEEE 754-2008 section 5.11).

PartialOrd requires your type to be PartialEq.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. It’s easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

If your type is Ord, you can implement partial_cmp by using cmp:

use std::cmp::Ordering;

#[derive(Eq)]
struct Person {
    id: u32,
    name: String,
    height: u32,
}

impl PartialOrd for Person {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Person {
    fn cmp(&self, other: &Self) -> Ordering {
        self.height.cmp(&other.height)
    }
}

impl PartialEq for Person {
    fn eq(&self, other: &Self) -> bool {
        self.height == other.height
    }
}

You may also find it useful to use partial_cmp on your type’s fields. Here is an example of Person types who have a floating-point height field that is the only field to be used for sorting:

use std::cmp::Ordering;

struct Person {
    id: u32,
    name: String,
    height: f64,
}

impl PartialOrd for Person {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.height.partial_cmp(&other.height)
    }
}

impl PartialEq for Person {
    fn eq(&self, other: &Self) -> bool {
        self.height == other.height
    }
}

Examples

let x : u32 = 0;
let y : u32 = 1;

assert_eq!(x < y, true);
assert_eq!(x.lt(&y), true);

Required methods

#[must_use]

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

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

Examples

use std::cmp::Ordering;

let result = 1.0.partial_cmp(&2.0);
assert_eq!(result, Some(Ordering::Less));

let result = 1.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Equal));

let result = 2.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Greater));

When comparison is impossible:

let result = f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);

Loading content...

Provided methods

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

Examples

let result = 1.0 < 2.0;
assert_eq!(result, true);

let result = 2.0 < 1.0;
assert_eq!(result, false);

#[must_use]

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

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

Examples

let result = 1.0 <= 2.0;
assert_eq!(result, true);

let result = 2.0 <= 2.0;
assert_eq!(result, true);

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

Examples

let result = 1.0 > 2.0;
assert_eq!(result, false);

let result = 2.0 > 2.0;
assert_eq!(result, false);

#[must_use]

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

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

Examples

let result = 2.0 >= 1.0;
assert_eq!(result, true);

let result = 2.0 >= 2.0;
assert_eq!(result, true);

Loading content...

Implementations on Foreign Types

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for OsString

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl PartialOrd<Ipv6Addr> for IpAddr

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

impl PartialOrd<SocketAddrV4> for SocketAddrV4

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

impl<'a, 'b> PartialOrd<OsString> for &'a Path

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

impl PartialOrd<IpAddr> for IpAddr

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

impl PartialOrd<OsString> for OsString

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

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

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

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

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

impl PartialOrd<str> for OsString

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

impl PartialOrd<Path> for Path

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

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for &'a Path

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

impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>

pub fn partial_cmp(&self, other: &Prefix<'a>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for Path

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

impl<'a, 'b> PartialOrd<OsString> for Path

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

impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path

pub fn partial_cmp(&self, other: &Cow<'b, OsStr>) -> Option<Ordering>

impl PartialOrd<Ipv4Addr> for Ipv4Addr

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

impl PartialOrd<IpAddr> for Ipv6Addr

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

impl<'a> PartialOrd<Components<'a>> for Components<'a>

pub fn partial_cmp(&self, other: &Components<'a>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a OsStr> for Path

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for OsString

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

impl<'a, 'b> PartialOrd<&'a OsStr> for OsString

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Path

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

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl PartialOrd<SocketAddrV6> for SocketAddrV6

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

impl<'a> PartialOrd<Component<'a>> for Component<'a>

pub fn partial_cmp(&self, other: &Component<'a>) -> Option<Ordering>

impl PartialOrd<Ipv4Addr> for IpAddr

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

impl<'a, 'b> PartialOrd<PathBuf> for OsString

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

impl<'a, 'b> PartialOrd<OsStr> for OsString

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

impl PartialOrd<CStr> for CStr

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

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl PartialOrd<IpAddr> for Ipv4Addr

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

impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>

pub fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<Ordering>

impl PartialOrd<CString> for CString

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

impl<'a, 'b> PartialOrd<OsStr> for &'a Path

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

impl PartialOrd<Ipv6Addr> for Ipv6Addr

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

impl PartialOrd<SocketAddr> for SocketAddr

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

impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: PartialOrd<C> + PartialEq<C>,
    L: PartialOrd<L> + PartialEq<L> + ?Sized,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    K: PartialOrd<K> + PartialEq<K>,
    I: PartialOrd<I> + PartialEq<I>,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G>,
    D: PartialOrd<D> + PartialEq<D>,
    H: PartialOrd<H> + PartialEq<H>,
    J: PartialOrd<J> + PartialEq<J>, 

pub fn partial_cmp(
    &self,
    other: &(A, B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

pub fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>

impl PartialOrd<i128> for i128

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

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

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

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

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

impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>

impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

pub fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>

impl<A> PartialOrd<(A,)> for (A,) where
    A: PartialOrd<A> + PartialEq<A> + ?Sized, 

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>

impl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
    B: ?Sized,
    A: PartialOrd<B> + ?Sized, 

pub fn partial_cmp(&self, other: &&mut B) -> Option<Ordering>

pub fn lt(&self, other: &&mut B) -> bool

pub fn le(&self, other: &&mut B) -> bool

pub fn gt(&self, other: &&mut B) -> bool

pub fn ge(&self, other: &&mut B) -> bool

impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret

pub fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>

impl PartialOrd<()> for ()

pub fn partial_cmp(&self, &()) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

pub fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>

impl PartialOrd<i8> for i8

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

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

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

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    K: PartialOrd<K> + PartialEq<K> + ?Sized,
    I: PartialOrd<I> + PartialEq<I>,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G>,
    D: PartialOrd<D> + PartialEq<D>,
    H: PartialOrd<H> + PartialEq<H>,
    J: PartialOrd<J> + PartialEq<J>, 

pub fn partial_cmp(
    &self,
    other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>

impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    A: PartialOrd<A> + PartialEq<A>,
    D: PartialOrd<D> + PartialEq<D> + ?Sized, 

pub fn partial_cmp(&self, other: &(A, B, C, D)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D)) -> bool

pub fn le(&self, other: &(A, B, C, D)) -> bool

pub fn ge(&self, other: &(A, B, C, D)) -> bool

pub fn gt(&self, other: &(A, B, C, D)) -> bool

impl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

pub fn lt(&self, other: &[T; N]) -> bool

pub fn le(&self, other: &[T; N]) -> bool

pub fn ge(&self, other: &[T; N]) -> bool

pub fn gt(&self, other: &[T; N]) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G>,
    D: PartialOrd<D> + PartialEq<D>,
    H: PartialOrd<H> + PartialEq<H> + ?Sized, 

pub fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>

impl PartialOrd<i64> for i64

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>

impl PartialOrd<isize> for isize

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    I: PartialOrd<I> + PartialEq<I>,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G>,
    D: PartialOrd<D> + PartialEq<D>,
    H: PartialOrd<H> + PartialEq<H>,
    J: PartialOrd<J> + PartialEq<J> + ?Sized, 

pub fn partial_cmp(
    &self,
    other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>

impl<T> PartialOrd<*mut T> for *mut T where
    T: ?Sized, 

pub fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>

pub fn lt(&self, other: &*mut T) -> bool

pub fn le(&self, other: &*mut T) -> bool

pub fn gt(&self, other: &*mut T) -> bool

pub fn ge(&self, other: &*mut T) -> bool

impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

pub fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

pub fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>

impl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
    B: ?Sized,
    A: PartialOrd<B> + ?Sized, 

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

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

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

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

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

impl PartialOrd<u64> for u64

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

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

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

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

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

impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>

impl<T> PartialOrd<[T]> for [T] where
    T: PartialOrd<T>, 

Implements comparison of vectors lexicographically.

pub fn partial_cmp(&self, other: &[T]) -> Option<Ordering>

impl PartialOrd<u8> for u8

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

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

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

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

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

impl PartialOrd<i16> for i16

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

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

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

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

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

impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>

impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    I: PartialOrd<I> + PartialEq<I> + ?Sized,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G>,
    D: PartialOrd<D> + PartialEq<D>,
    H: PartialOrd<H> + PartialEq<H>, 

pub fn partial_cmp(
    &self,
    other: &(A, B, C, D, E, F, G, H, I)
) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

impl PartialOrd<usize> for usize

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>

impl PartialOrd<i32> for i32

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

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

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

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

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

impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B) -> Ret
) -> Option<Ordering>

impl<A, B> PartialOrd<(A, B)> for (A, B) where
    B: PartialOrd<B> + PartialEq<B> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>, 

pub fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B)) -> bool

pub fn le(&self, other: &(A, B)) -> bool

pub fn ge(&self, other: &(A, B)) -> bool

pub fn gt(&self, other: &(A, B)) -> bool

impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>

impl PartialOrd<u32> for u32

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

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

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

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

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

impl PartialOrd<u16> for u16

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>

impl PartialOrd<bool> for bool

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>

impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn() -> Ret
) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>

impl<T> PartialOrd<*const T> for *const T where
    T: ?Sized, 

pub fn partial_cmp(&self, other: &*const T) -> Option<Ordering>

pub fn lt(&self, other: &*const T) -> bool

pub fn le(&self, other: &*const T) -> bool

pub fn gt(&self, other: &*const T) -> bool

pub fn ge(&self, other: &*const T) -> bool

impl PartialOrd<u128> for u128

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

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

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

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

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

impl PartialOrd<!> for !

pub fn partial_cmp(&self, &!) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    F: PartialOrd<F> + PartialEq<F> + ?Sized,
    D: PartialOrd<D> + PartialEq<D>, 

pub fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F)) -> bool

impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    F: PartialOrd<F> + PartialEq<F>,
    G: PartialOrd<G> + PartialEq<G> + ?Sized,
    D: PartialOrd<D> + PartialEq<D>, 

pub fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool

impl PartialOrd<f64> for f64

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>

impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
    C: PartialOrd<C> + PartialEq<C> + ?Sized,
    B: PartialOrd<B> + PartialEq<B>,
    A: PartialOrd<A> + PartialEq<A>, 

pub fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C)) -> bool

pub fn le(&self, other: &(A, B, C)) -> bool

pub fn ge(&self, other: &(A, B, C)) -> bool

pub fn gt(&self, other: &(A, B, C)) -> bool

impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret

pub fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>

impl PartialOrd<char> for char

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

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

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

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

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>

impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
    C: PartialOrd<C> + PartialEq<C>,
    B: PartialOrd<B> + PartialEq<B>,
    E: PartialOrd<E> + PartialEq<E> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>,
    D: PartialOrd<D> + PartialEq<D>, 

pub fn partial_cmp(&self, other: &(A, B, C, D, E)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E)) -> bool

pub fn le(&self, other: &(A, B, C, D, E)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E)) -> bool

impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

pub fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

pub fn partial_cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>

impl PartialOrd<str> for str

Implements comparison operations on strings.

Strings are compared lexicographically by their byte values. This compares Unicode code points based on their positions in the code charts. This is not necessarily the same as “alphabetical” order, which varies by language and locale. Comparing strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the str type.

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

impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

pub fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>

impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret

pub fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>

impl PartialOrd<f32> for f32

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

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

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

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

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

impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret

pub fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>

impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret

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

impl<T> PartialOrd<Rc<T>> for Rc<T> where
    T: PartialOrd<T> + ?Sized, 

pub fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>

Partial comparison for two Rcs.

The two are compared by calling partial_cmp() on their inner values.

Examples

use std::rc::Rc;
use std::cmp::Ordering;

let five = Rc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));

pub fn lt(&self, other: &Rc<T>) -> bool

Less-than comparison for two Rcs.

The two are compared by calling < on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five < Rc::new(6));

pub fn le(&self, other: &Rc<T>) -> bool

‘Less than or equal to’ comparison for two Rcs.

The two are compared by calling <= on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five <= Rc::new(5));

pub fn gt(&self, other: &Rc<T>) -> bool

Greater-than comparison for two Rcs.

The two are compared by calling > on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five > Rc::new(4));

pub fn ge(&self, other: &Rc<T>) -> bool

‘Greater than or equal to’ comparison for two Rcs.

The two are compared by calling >= on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five >= Rc::new(5));

impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>

impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
    T: PartialOrd<T> + ?Sized,
    A: Allocator, 

pub fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>

pub fn lt(&self, other: &Box<T, A>) -> bool

pub fn le(&self, other: &Box<T, A>) -> bool

pub fn ge(&self, other: &Box<T, A>) -> bool

pub fn gt(&self, other: &Box<T, A>) -> bool

impl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
    T: PartialOrd<T>,
    A: Allocator, 

Implements comparison of vectors, lexicographically.

pub fn partial_cmp(&self, other: &Vec<T, A>) -> Option<Ordering>

impl PartialOrd<String> for String

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

impl PartialOrd<FaceId> for usize

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

impl PartialOrd<DescId> for usize

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

impl PartialOrd<Notch> for usize

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

impl PartialOrd<InHand> for usize

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

impl PartialOrd<SvgId> for usize

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

impl<A> PartialOrd<ArrayString<A>> for str where
    A: Array<Item = u8> + Copy, 

pub fn partial_cmp(&self, rhs: &ArrayString<A>) -> Option<Ordering>

pub fn lt(&self, rhs: &ArrayString<A>) -> bool

pub fn le(&self, rhs: &ArrayString<A>) -> bool

pub fn gt(&self, rhs: &ArrayString<A>) -> bool

pub fn ge(&self, rhs: &ArrayString<A>) -> bool

impl<Sep, T> PartialOrd<StringWithSeparator<Sep, T>> for StringWithSeparator<Sep, T> where
    T: PartialOrd<T>,
    Sep: PartialOrd<Sep>, 

pub fn partial_cmp(
    &self,
    other: &StringWithSeparator<Sep, T>
) -> Option<Ordering>

impl PartialOrd<CommaSeparator> for CommaSeparator

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

impl PartialOrd<SpaceSeparator> for SpaceSeparator

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

impl PartialOrd<Timespec> for Timespec

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

impl PartialOrd<Tm> for Tm

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

impl PartialOrd<SteadyTime> for SteadyTime

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

impl PartialOrd<Char> for char

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

impl PartialOrd<Utf8Range> for Utf8Range

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

impl PartialOrd<Span> for Span

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

impl PartialOrd<Literal> for Literal

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

impl PartialOrd<Position> for Position

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

impl PartialOrd<ClassBytesRange> for ClassBytesRange

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

impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange

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

impl PartialOrd<Utf8Sequence> for Utf8Sequence

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

impl PartialOrd<DwAccess> for DwAccess

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

impl PartialOrd<DwLns> for DwLns

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

impl PartialOrd<DwEnd> for DwEnd

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

impl PartialOrd<DwAte> for DwAte

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

impl<T> PartialOrd<ArangeEntry<T>> for ArangeEntry<T> where
    T: Copy + Ord, 

pub fn partial_cmp(&self, other: &ArangeEntry<T>) -> Option<Ordering>

impl<T> PartialOrd<DebugInfoOffset<T>> for DebugInfoOffset<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &DebugInfoOffset<T>) -> Option<Ordering>

impl PartialOrd<DwForm> for DwForm

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

impl PartialOrd<ColumnType> for ColumnType

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

impl PartialOrd<SectionId> for SectionId

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

impl PartialOrd<DwEhPe> for DwEhPe

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

impl PartialOrd<DwChildren> for DwChildren

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

impl PartialOrd<DwLle> for DwLle

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

impl PartialOrd<DwOp> for DwOp

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

impl PartialOrd<DwId> for DwId

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

impl PartialOrd<DwAt> for DwAt

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

impl PartialOrd<DwAddr> for DwAddr

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

impl PartialOrd<DwMacro> for DwMacro

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

impl PartialOrd<DwLne> for DwLne

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

impl PartialOrd<DwVis> for DwVis

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

impl PartialOrd<DwVirtuality> for DwVirtuality

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

impl PartialOrd<DwIdx> for DwIdx

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

impl PartialOrd<DwLnct> for DwLnct

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

impl PartialOrd<DwDefaulted> for DwDefaulted

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

impl PartialOrd<DwDs> for DwDs

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

impl PartialOrd<DwUt> for DwUt

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

impl PartialOrd<DwOrd> for DwOrd

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

impl<T> PartialOrd<UnitOffset<T>> for UnitOffset<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &UnitOffset<T>) -> Option<Ordering>

impl PartialOrd<DwTag> for DwTag

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

impl PartialOrd<DwCfa> for DwCfa

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

impl PartialOrd<DwRle> for DwRle

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

impl PartialOrd<DwDsc> for DwDsc

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

impl PartialOrd<DwCc> for DwCc

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

impl PartialOrd<Register> for Register

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

impl PartialOrd<DwLang> for DwLang

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

impl PartialOrd<DwInl> for DwInl

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

impl<T> PartialOrd<UnitSectionOffset<T>> for UnitSectionOffset<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &UnitSectionOffset<T>) -> Option<Ordering>

impl<T> PartialOrd<DebugTypesOffset<T>> for DebugTypesOffset<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &DebugTypesOffset<T>) -> Option<Ordering>

impl<E> PartialOrd<U16Bytes<E>> for U16Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &U16Bytes<E>) -> Option<Ordering>

impl<E> PartialOrd<U64Bytes<E>> for U64Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &U64Bytes<E>) -> Option<Ordering>

impl<E> PartialOrd<I16Bytes<E>> for I16Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &I16Bytes<E>) -> Option<Ordering>

impl<E> PartialOrd<I32Bytes<E>> for I32Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &I32Bytes<E>) -> Option<Ordering>

impl<E> PartialOrd<I64Bytes<E>> for I64Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &I64Bytes<E>) -> Option<Ordering>

impl<E> PartialOrd<U32Bytes<E>> for U32Bytes<E> where
    E: PartialOrd<E> + Endian, 

pub fn partial_cmp(&self, other: &U32Bytes<E>) -> Option<Ordering>

impl<T> PartialOrd<Paint<T>> for Paint<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &Paint<T>) -> Option<Ordering>

impl PartialOrd<Style> for Style

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

impl PartialOrd<Color> for Color

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

impl PartialOrd<RecursiveMode> for RecursiveMode

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

impl PartialOrd<Op> for Op

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

impl PartialOrd<FileTime> for FileTime

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

impl PartialOrd<UnixReady> for UnixReady

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

impl PartialOrd<Token> for Token

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

impl PartialOrd<PollOpt> for PollOpt

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

impl PartialOrd<Ready> for Ready

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

impl PartialOrd<WatchMask> for WatchMask

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

impl PartialOrd<EventMask> for EventMask

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

impl<A> PartialOrd<SmallVec<A>> for SmallVec<A> where
    A: Array,
    <A as Array>::Item: PartialOrd<<A as Array>::Item>, 

pub fn partial_cmp(&self, other: &SmallVec<A>) -> Option<Ordering>

impl PartialOrd<BigEndian> for BigEndian

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

impl PartialOrd<LittleEndian> for LittleEndian

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

impl<S> PartialOrd<Host<S>> for Host<S> where
    S: PartialOrd<S>, 

pub fn partial_cmp(&self, other: &Host<S>) -> Option<Ordering>

impl PartialOrd<Level> for Level

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

impl<A> PartialOrd<TinyVec<A>> for TinyVec<A> where
    A: Array,
    <A as Array>::Item: PartialOrd<<A as Array>::Item>, 

#[must_use]

pub fn partial_cmp(&self, other: &TinyVec<A>) -> Option<Ordering>

impl<A> PartialOrd<ArrayVec<A>> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialOrd<<A as Array>::Item>, 

#[must_use]

pub fn partial_cmp(&self, other: &ArrayVec<A>) -> Option<Ordering>

impl<'s, T> PartialOrd<SliceVec<'s, T>> for SliceVec<'s, T> where
    T: PartialOrd<T>, 

#[must_use]

pub fn partial_cmp(&self, other: &SliceVec<'s, T>) -> Option<Ordering>

impl PartialOrd<MatchOptions> for MatchOptions

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

impl PartialOrd<Pattern> for Pattern

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

impl<'i> PartialOrd<Position<'i>> for Position<'i>

pub fn partial_cmp(&self, other: &Position<'i>) -> Option<Ordering>

impl<S> PartialOrd<Host<S>> for Host<S> where
    S: PartialOrd<S>, 

pub fn partial_cmp(&self, other: &Host<S>) -> Option<Ordering>

impl PartialOrd<Url> for Url

URLs compare like their serialization.

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

impl PartialOrd<UnicodeVersion> for UnicodeVersion

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

impl<V> PartialOrd<VecMap<V>> for VecMap<V> where
    V: PartialOrd<V>, 

pub fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering>

Loading content...

Implementors

impl PartialOrd<AccountScope> for AccountScope

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

impl PartialOrd<LinkKind> for LinkKind

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

impl PartialOrd<OccultationKindGeneral<(OccDisplacement, ZCoord)>> for OccultationKindGeneral<(OccDisplacement, ZCoord)>

pub fn partial_cmp(
    &self,
    rhs: &OccultationKindGeneral<(OccDisplacement, ZCoord)>
) -> Option<Ordering>

impl PartialOrd<PieceMoveable> for PieceMoveable

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

impl PartialOrd<StaticUser> for StaticUser

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

impl PartialOrd<TablePermission> for TablePermission

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

impl PartialOrd<Level> for otter_api_tests::flexi_logger::Level

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

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

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

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

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

impl PartialOrd<Level> for LevelFilter

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

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

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

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

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

impl PartialOrd<LevelFilter> for otter_api_tests::flexi_logger::Level

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

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

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

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

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

impl PartialOrd<LevelFilter> for LevelFilter

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

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

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

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

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

impl PartialOrd<PosixFadviseAdvice> for PosixFadviseAdvice

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

impl PartialOrd<AioFsyncMode> for AioFsyncMode

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

impl PartialOrd<LioMode> for LioMode

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

impl PartialOrd<LioOpcode> for LioOpcode

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

impl PartialOrd<MmapAdvise> for MmapAdvise

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

impl PartialOrd<Event> for Event

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

impl PartialOrd<Request> for Request

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

impl PartialOrd<QuotaFmt> for QuotaFmt

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

impl PartialOrd<QuotaType> for QuotaType

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

impl PartialOrd<RebootMode> for RebootMode

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

impl PartialOrd<SigmaskHow> for SigmaskHow

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

impl PartialOrd<Signal> for Signal

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

impl PartialOrd<BaudRate> for BaudRate

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

impl PartialOrd<FlowArg> for FlowArg

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

impl PartialOrd<FlushArg> for FlushArg

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

impl PartialOrd<SetArg> for SetArg

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

impl PartialOrd<SpecialCharacterIndices> for SpecialCharacterIndices

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

impl PartialOrd<ClockId> for otter_api_tests::imports::nix::sys::timerfd::ClockId

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

impl PartialOrd<ErrorKind> for ErrorKind

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

impl PartialOrd<Infallible> for Infallible

pub fn partial_cmp(&self, _other: &Infallible) -> Option<Ordering>

impl PartialOrd<Ordering> for Ordering

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

impl PartialOrd<str> for OsStr

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

impl PartialOrd<usize> for DescId

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

impl PartialOrd<usize> for SvgId

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

impl PartialOrd<usize> for FaceId

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

impl PartialOrd<usize> for Notch

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

impl PartialOrd<Error> for Error

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

impl PartialOrd<Duration> for otter_api_tests::imports::chrono::Duration

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

impl PartialOrd<IsoWeek> for IsoWeek

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

impl PartialOrd<NaiveDate> for NaiveDate

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

impl PartialOrd<NaiveDateTime> for NaiveDateTime

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

impl PartialOrd<NaiveTime> for NaiveTime

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

impl PartialOrd<TypeId> for TypeId

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

impl PartialOrd<CpuidResult> for CpuidResult

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

impl PartialOrd<PhantomPinned> for PhantomPinned

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

impl PartialOrd<NonZeroI8> for NonZeroI8

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

impl PartialOrd<NonZeroI16> for NonZeroI16

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

impl PartialOrd<NonZeroI32> for NonZeroI32

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

impl PartialOrd<NonZeroI64> for NonZeroI64

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

impl PartialOrd<NonZeroI128> for NonZeroI128

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

impl PartialOrd<NonZeroIsize> for NonZeroIsize

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

impl PartialOrd<NonZeroU8> for NonZeroU8

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

impl PartialOrd<NonZeroU16> for NonZeroU16

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

impl PartialOrd<NonZeroU32> for NonZeroU32

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

impl PartialOrd<NonZeroU64> for NonZeroU64

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

impl PartialOrd<NonZeroU128> for NonZeroU128

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

impl PartialOrd<NoneError> for NoneError

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

impl PartialOrd<MatchOptions> for otter_api_tests::imports::glob::MatchOptions

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

impl PartialOrd<Pattern> for otter_api_tests::imports::glob::Pattern

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

impl PartialOrd<AtFlags> for AtFlags

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

impl PartialOrd<FallocateFlags> for FallocateFlags

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

impl PartialOrd<FdFlag> for otter_api_tests::imports::nix::fcntl::FdFlag

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

impl PartialOrd<OFlag> for OFlag

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

impl PartialOrd<SealFlag> for SealFlag

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

impl PartialOrd<SpliceFFlags> for SpliceFFlags

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

impl PartialOrd<DeleteModuleFlags> for DeleteModuleFlags

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

impl PartialOrd<ModuleInitFlags> for ModuleInitFlags

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

impl PartialOrd<MntFlags> for MntFlags

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

impl PartialOrd<MsFlags> for otter_api_tests::imports::nix::mount::MsFlags

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

impl PartialOrd<FdFlag> for otter_api_tests::imports::nix::mqueue::FdFlag

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

impl PartialOrd<MQ_OFlag> for MQ_OFlag

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

impl PartialOrd<InterfaceFlags> for InterfaceFlags

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

impl PartialOrd<PollFlags> for PollFlags

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

impl PartialOrd<CloneFlags> for CloneFlags

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

impl PartialOrd<EpollCreateFlags> for EpollCreateFlags

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

impl PartialOrd<EpollFlags> for EpollFlags

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

impl PartialOrd<EfdFlags> for EfdFlags

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

impl PartialOrd<AddWatchFlags> for AddWatchFlags

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

impl PartialOrd<InitFlags> for InitFlags

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

impl PartialOrd<WatchDescriptor> for WatchDescriptor

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

impl PartialOrd<MemFdCreateFlag> for MemFdCreateFlag

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

impl PartialOrd<MRemapFlags> for MRemapFlags

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

impl PartialOrd<MapFlags> for MapFlags

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

impl PartialOrd<MlockAllFlags> for MlockAllFlags

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

impl PartialOrd<MsFlags> for otter_api_tests::imports::nix::sys::mman::MsFlags

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

impl PartialOrd<ProtFlags> for ProtFlags

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

impl PartialOrd<Persona> for Persona

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

impl PartialOrd<Options> for Options

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

impl PartialOrd<QuotaValidFlags> for QuotaValidFlags

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

impl PartialOrd<SaFlags> for SaFlags

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

impl PartialOrd<SfdFlags> for SfdFlags

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

impl PartialOrd<MsgFlags> for MsgFlags

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

impl PartialOrd<SockFlag> for SockFlag

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

impl PartialOrd<Mode> for Mode

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

impl PartialOrd<SFlag> for SFlag

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

impl PartialOrd<FsFlags> for FsFlags

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

impl PartialOrd<ControlFlags> for ControlFlags

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

impl PartialOrd<InputFlags> for InputFlags

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

impl PartialOrd<LocalFlags> for LocalFlags

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

impl PartialOrd<OutputFlags> for OutputFlags

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

impl PartialOrd<TimeVal> for TimeVal

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

impl PartialOrd<TimerFlags> for TimerFlags

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

impl PartialOrd<TimerSetTimeFlags> for TimerSetTimeFlags

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

impl PartialOrd<WaitPidFlag> for WaitPidFlag

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

impl PartialOrd<ClockId> for otter_api_tests::imports::nix::time::ClockId

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

impl PartialOrd<DefaultKey> for DefaultKey

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

impl PartialOrd<KeyData> for KeyData

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

impl PartialOrd<UpdateId> for UpdateId

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

impl PartialOrd<DescId> for DescId

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

impl PartialOrd<Duration> for otter_api_tests::shapelib::Duration

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

impl PartialOrd<Instant> for Instant

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

impl PartialOrd<ItemEnquiryData> for ItemEnquiryData

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

impl PartialOrd<NonZeroUsize> for NonZeroUsize

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

impl PartialOrd<OsStr> for OsStr

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

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

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

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

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

impl PartialOrd<PathBuf> for PathBuf

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

impl PartialOrd<SvgId> for SvgId

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

impl PartialOrd<TimeSpec> for TimeSpec

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

impl PartialOrd<Url> for otter_api_tests::shapelib::Url

URLs compare like their serialization.

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

impl PartialOrd<ZCoord> for ZCoord

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

impl PartialOrd<AccountId> for AccountId

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

impl PartialOrd<AccountName> for AccountName

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

impl PartialOrd<AccountNotFound> for AccountNotFound

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

impl PartialOrd<ClientId> for ClientId

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

impl PartialOrd<FaceId> for FaceId

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

impl PartialOrd<Generation> for Generation

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

impl PartialOrd<GoodItemName> for GoodItemName

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

impl PartialOrd<Html> for Html

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

impl PartialOrd<HtmlLit> for HtmlLit

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

impl PartialOrd<HtmlStr> for HtmlStr

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

impl PartialOrd<InstanceName> for InstanceName

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

impl PartialOrd<Notch> for Notch

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

impl PartialOrd<OccId> for OccId

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

impl PartialOrd<OccultIlkId> for OccultIlkId

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

impl PartialOrd<OccultIlkName> for OccultIlkName

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

impl PartialOrd<PieceId> for PieceId

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

impl PartialOrd<PlayerId> for PlayerId

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

impl PartialOrd<PlayerNotFound> for PlayerNotFound

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

impl PartialOrd<RawToken> for RawToken

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

impl PartialOrd<RawTokenVal> for RawTokenVal

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

impl PartialOrd<Timestamp> for Timestamp

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

impl PartialOrd<TokenRevelationKey> for TokenRevelationKey

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

impl PartialOrd<UrlSpec> for UrlSpec

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

impl PartialOrd<VisiblePieceId> for VisiblePieceId

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

impl PartialOrd<ZLevel> for ZLevel

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

impl PartialOrd<SystemTime> for SystemTime

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

impl PartialOrd<AccessFlags> for AccessFlags

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

impl PartialOrd<Pid> for Pid

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

impl PartialOrd<LimbVal> for LimbVal

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

impl<'a> PartialOrd<Location<'a>> for Location<'a>

pub fn partial_cmp(&self, other: &Location<'a>) -> Option<Ordering>

impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>

pub fn partial_cmp(&self, other: &Metadata<'a>) -> Option<Ordering>

impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>

pub fn partial_cmp(&self, other: &MetadataBuilder<'a>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for OsStr

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for PathBuf

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>

pub fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &&'b Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>

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

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>

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

impl<'a, 'b> PartialOrd<OsStr> for PathBuf

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

impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr

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

impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>

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

impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>

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

impl<'a, 'b> PartialOrd<PathBuf> for OsStr

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

impl<'a, 'b> PartialOrd<OsString> for &'a OsStr

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

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>

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

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>

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

impl<'a, 'b> PartialOrd<OsString> for OsStr

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

impl<'a, 'b> PartialOrd<OsString> for PathBuf

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

impl<'a, 'b> PartialOrd<Path> for &'a OsStr

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

impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>

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

impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>

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

impl<'a, 'b> PartialOrd<Path> for OsStr

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

impl<'a, 'b> PartialOrd<Path> for PathBuf

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

impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
    B: PartialOrd<B> + ToOwned + ?Sized, 

pub fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

impl<A> PartialOrd<str> for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn partial_cmp(&self, rhs: &str) -> Option<Ordering>

pub fn lt(&self, rhs: &str) -> bool

pub fn le(&self, rhs: &str) -> bool

pub fn gt(&self, rhs: &str) -> bool

pub fn ge(&self, rhs: &str) -> bool

impl<A> PartialOrd<ArrayString<A>> for ArrayString<A> where
    A: Array<Item = u8> + Copy, 

pub fn partial_cmp(&self, rhs: &ArrayString<A>) -> Option<Ordering>

pub fn lt(&self, rhs: &ArrayString<A>) -> bool

pub fn le(&self, rhs: &ArrayString<A>) -> bool

pub fn gt(&self, rhs: &ArrayString<A>) -> bool

pub fn ge(&self, rhs: &ArrayString<A>) -> bool

impl<A> PartialOrd<ArrayVec<A>> for otter_api_tests::shapelib::ArrayVec<A> where
    A: Array,
    <A as Array>::Item: PartialOrd<<A as Array>::Item>, 

pub fn partial_cmp(&self, other: &ArrayVec<A>) -> Option<Ordering>

pub fn lt(&self, other: &ArrayVec<A>) -> bool

pub fn le(&self, other: &ArrayVec<A>) -> bool

pub fn ge(&self, other: &ArrayVec<A>) -> bool

pub fn gt(&self, other: &ArrayVec<A>) -> bool

impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
    A: PartialOrd<A>, 

pub fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering>

impl<Dyn> PartialOrd<DynMetadata<Dyn>> for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn partial_cmp(&self, other: &DynMetadata<Dyn>) -> Option<Ordering>

impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
    T: PartialOrd<T>,
    I: Idx, 

pub fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>

impl<I, T> PartialOrd<IndexVec<I, T>> for IndexVec<I, T> where
    T: PartialOrd<T>,
    I: PartialOrd<I> + Idx, 

pub fn partial_cmp(&self, other: &IndexVec<I, T>) -> Option<Ordering>

impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
    K: PartialOrd<K>,
    V: PartialOrd<V>, 

pub fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering>

impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
    L: PartialOrd<L>,
    R: PartialOrd<R>, 

pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
    P: Deref,
    Q: Deref,
    <P as Deref>::Target: PartialOrd<<Q as Deref>::Target>, 

pub fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>

pub fn lt(&self, other: &Pin<Q>) -> bool

pub fn le(&self, other: &Pin<Q>) -> bool

pub fn gt(&self, other: &Pin<Q>) -> bool

pub fn ge(&self, other: &Pin<Q>) -> bool

impl<T> PartialOrd<RegionC<T>> for RegionC<T> where
    T: PartialOrd<T> + Copy, 

pub fn partial_cmp(&self, other: &RegionC<T>) -> Option<Ordering>

impl<T> PartialOrd<Option<T>> for Option<T> where
    T: PartialOrd<T>, 

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

impl<T> PartialOrd<Poll<T>> for Poll<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &Poll<T>) -> Option<Ordering>

impl<T> PartialOrd<Cell<T>> for Cell<T> where
    T: PartialOrd<T> + Copy, 

pub fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering>

pub fn lt(&self, other: &Cell<T>) -> bool

pub fn le(&self, other: &Cell<T>) -> bool

pub fn gt(&self, other: &Cell<T>) -> bool

pub fn ge(&self, other: &Cell<T>) -> bool

impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

pub fn partial_cmp(&self, other: &NonNull<T>) -> Option<Ordering>

impl<T> PartialOrd<NotNan<T>> for NotNan<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &NotNan<T>) -> Option<Ordering>

impl<T> PartialOrd<CapacityError<T>> for CapacityError<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &CapacityError<T>) -> Option<Ordering>

impl<T> PartialOrd<Spanned<T>> for Spanned<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &Spanned<T>) -> Option<Ordering>

impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
    T: PartialOrd<T> + ?Sized, 

pub fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering>

impl<T> PartialOrd<Arc<T>> for Arc<T> where
    T: PartialOrd<T> + ?Sized, 

pub fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>

Partial comparison for two Arcs.

The two are compared by calling partial_cmp() on their inner values.

Examples

use std::sync::Arc;
use std::cmp::Ordering;

let five = Arc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));

pub fn lt(&self, other: &Arc<T>) -> bool

Less-than comparison for two Arcs.

The two are compared by calling < on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five < Arc::new(6));

pub fn le(&self, other: &Arc<T>) -> bool

‘Less than or equal to’ comparison for two Arcs.

The two are compared by calling <= on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five <= Arc::new(5));

pub fn gt(&self, other: &Arc<T>) -> bool

Greater-than comparison for two Arcs.

The two are compared by calling > on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five > Arc::new(4));

pub fn ge(&self, other: &Arc<T>) -> bool

‘Greater than or equal to’ comparison for two Arcs.

The two are compared by calling >= on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five >= Arc::new(5));

impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &BTreeSet<T>) -> Option<Ordering>

impl<T> PartialOrd<OrderedFloat<T>> for OrderedFloat<T> where
    T: Float, 

pub fn partial_cmp(&self, other: &OrderedFloat<T>) -> Option<Ordering>

impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

pub fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<Ordering>

impl<T> PartialOrd<PosC<T>> for PosC<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &PosC<T>) -> Option<Ordering>

impl<T> PartialOrd<RectC<T>> for RectC<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &RectC<T>) -> Option<Ordering>

impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>

impl<T> PartialOrd<IsHtmlFormatted<T>> for IsHtmlFormatted<T> where
    T: PartialOrd<T> + Display, 

pub fn partial_cmp(&self, other: &IsHtmlFormatted<T>) -> Option<Ordering>

impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
    T: PartialOrd<T> + ?Sized, 

pub fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn lt(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn le(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn gt(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn ge(&self, other: &RefCell<T>) -> bool

Panics

Panics if the value in either RefCell is currently borrowed.

impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering>

pub fn lt(&self, other: &Reverse<T>) -> bool

pub fn le(&self, other: &Reverse<T>) -> bool

pub fn gt(&self, other: &Reverse<T>) -> bool

pub fn ge(&self, other: &Reverse<T>) -> bool

impl<T> PartialOrd<T> for Void

pub fn partial_cmp(&self, &T) -> Option<Ordering>

impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
    T: PartialOrd<T>,
    E: PartialOrd<E>, 

pub fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

impl<Tz> PartialOrd<Date<Tz>> for Date<Tz> where
    Tz: TimeZone, 

pub fn partial_cmp(&self, other: &Date<Tz>) -> Option<Ordering>

impl<Tz, Tz2> PartialOrd<DateTime<Tz2>> for DateTime<Tz> where
    Tz: TimeZone,
    Tz2: TimeZone, 

pub fn partial_cmp(&self, other: &DateTime<Tz2>) -> Option<Ordering>

Compare two DateTimes based on their true time, ignoring time zones

Example

use chrono::prelude::*;

let earlier = Utc.ymd(2015, 5, 15).and_hms(2, 0, 0).with_timezone(&FixedOffset::west(1 * 3600));
let later   = Utc.ymd(2015, 5, 15).and_hms(3, 0, 0).with_timezone(&FixedOffset::west(5 * 3600));

assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00");
assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00");

assert!(later > earlier);

impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialOrd<R>,
    Y: PartialOrd<Y>, 

pub fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>

Loading content...