Struct drop_tracker::DropItem

pub struct DropItem<V> { /* private fields */ }

An item that will notify the parent DropTracker once it gets dropped.

DropItem instances are created by DropTracker::track, DropTracker::track_with_value, and related functions. DropItem instances may contain an “underlying value” that affects the item behavior when used with standard traits. The underlying value is either:

• a clone of key when constructing an item using track(key) (implicit); or
• value when constructing an item using track_with_value(key, value) (explicit).

To check whether an item is alive or has been dropped, use DropTracker::state or see the documentation for DropTracker for alternatives.

Coercing and borrowing

DropItem instances may be coerced and borrowed as the the underlying value type. This means that, for example, if you create a DropItem using track(String::from("abc")), you may call all of the String methods on that item.

DropItem also implements the standard traits PartialEq, Eq, PartialOrd, Ord and Hash, Display, Debug if the type of the underlying value implements them.

Cloning

DropItem does not implement the Clone trait as it would introduce ambiguity with respect to understanding whether the item has been dropped or is still alive when using DropTracker::state.

Double drop

DropItem instances can be dropped twice or more. Doing so will cause a panic, but will not cause undefined behavior (unless you’re calling drop on an invalid memory location). The panic on double drop is an useful feature to detect logic errors in destructors.

Safety

Borrowing or performing operations on the underlying value of a DropItem is generally safe when using safe Rust code. However, DropItems are often used in unsafe code and are used to detect potential bugs. In those circumstances, it is possible to trigger undefined behavior. In particular, borrowing or performing operations on a DropItem while another thread is dropping will result in undefined behavior (although it must be noted that this is a bug in the caller code and is not something that should happen in safe Rust code).

Only Drop on a DropItem is guaranteed to be safe in all circumstances.

Examples

use drop_tracker::DropTracker;

let mut tracker = DropTracker::<u32>::new();

// Create an item using `123u32` as the key. Implicitly, this also sets its value to `123u32`
let item = tracker.track(123);

// Check that the item is alive
tracker.state(&123).alive().expect("item should be alive");

// Dereference the value of the item
assert_eq!(*item, 123);
assert!(!item.is_power_of_two());

// Drop the item and check that it really got dropped
drop(item);
tracker.state(&123).dropped().expect("item should be dropped");

// Create a new item, this time using an explicit `String` value
let abc_item = tracker.track_with_value(111, String::from("abc"));

// Comparison with other items using `String` work using the underlying `String`
// operations
assert_eq!(abc_item, tracker.track_with_value(222, String::from("abc")));
assert_ne!(abc_item, tracker.track_with_value(333, String::from("def")));
assert!(abc_item < tracker.track_with_value(444, String::from("def")));

// Display, debug and hashing also work using the underlying `String` operations
assert_eq!(format!("{}", abc_item), "abc");
assert_eq!(format!("{:?}", abc_item), "DropItem { value: \"abc\", state: Alive }");

use std::collections::hash_map::DefaultHasher;
use std::hash::Hash;
use std::hash::Hasher;
fn hash<T: Hash + ?Sized>(x: &T) -> u64 {
    let mut hasher = DefaultHasher::new();
    x.hash(&mut hasher);
    hasher.finish()
}
assert_eq!(hash(&abc_item), hash(&"abc"));

// Methods on `String` can be called transparently on items
assert_eq!(abc_item.to_ascii_uppercase(), "ABC");

Using hashable items in a set, with an implicit underlying value:

use drop_tracker::DropTracker;
use std::collections::HashSet;

let mut tracker = DropTracker::new();

let mut set = HashSet::from([
    tracker.track(1),
    tracker.track(2),
    tracker.track(3),
]);

set.remove(&3);

tracker.state(&1).alive().expect("first item should be alive");
tracker.state(&2).alive().expect("second item should be alive");
tracker.state(&3).dropped().expect("third item should be dropped");

Using hashable items in a set, with an explicit underlying value:

use drop_tracker::DropTracker;
use std::collections::HashSet;

let mut tracker = DropTracker::new();

let mut set = HashSet::from([
    tracker.track_with_value(1, String::from("first")),
    tracker.track_with_value(2, String::from("second")),
    tracker.track_with_value(3, String::from("third")),
]);

set.remove("third");

tracker.state(&1).alive().expect("first item should be alive");
tracker.state(&2).alive().expect("second item should be alive");
tracker.state(&3).dropped().expect("third item should be dropped");

Trait Implementations

impl<V: AsMut<T>, T> AsMut<T> for DropItem<V>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<V: AsRef<T>, T> AsRef<T> for DropItem<V>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<V: Borrow<[T]>, T> Borrow<[T]> for DropItem<V>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<V> Borrow<V> for DropItem<V>

fn borrow(&self) -> &V

Immutably borrows from an owned value.

impl<V: Borrow<str>> Borrow<str> for DropItem<V>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<V: BorrowMut<[T]>, T> BorrowMut<[T]> for DropItem<V>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<V> BorrowMut<V> for DropItem<V>

fn borrow_mut(&mut self) -> &mut V

Mutably borrows from an owned value.

impl<V: BorrowMut<str>> BorrowMut<str> for DropItem<V>

fn borrow_mut(&mut self) -> &mut str

Mutably borrows from an owned value.

impl<V: Debug> Debug for DropItem<V>

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

Formats the value using the given formatter.

impl<V> Deref for DropItem<V>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V> DerefMut for DropItem<V>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<V: Display> Display for DropItem<V>

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

Formats the value using the given formatter.

impl<V> Drop for DropItem<V>

fn drop(&mut self)

Executes the destructor for this type.

impl<V: Hash> Hash for DropItem<V>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, V, T> PartialEq<&'a [T]> for DropItem<V>where
    V: PartialEq<&'a [T]>,

fn eq(&self, other: &&'a [T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, V> PartialEq<&'a str> for DropItem<V>where
    V: PartialEq<&'a str>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, T> PartialEq<[T]> for DropItem<V>where
    V: PartialEq<[T]>,

fn eq(&self, other: &[T]) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<()> for DropItem<V>where
    V: PartialEq<()>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V: PartialEq<W>, W> PartialEq<DropItem<W>> for DropItem<V>

fn eq(&self, other: &DropItem<W>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<bool> for DropItem<V>where
    V: PartialEq<bool>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<char> for DropItem<V>where
    V: PartialEq<char>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<f32> for DropItem<V>where
    V: PartialEq<f32>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<f64> for DropItem<V>where
    V: PartialEq<f64>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<i128> for DropItem<V>where
    V: PartialEq<i128>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<i16> for DropItem<V>where
    V: PartialEq<i16>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<i32> for DropItem<V>where
    V: PartialEq<i32>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<i64> for DropItem<V>where
    V: PartialEq<i64>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<i8> for DropItem<V>where
    V: PartialEq<i8>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<str> for DropItem<V>where
    V: PartialEq<str>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<u128> for DropItem<V>where
    V: PartialEq<u128>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<u16> for DropItem<V>where
    V: PartialEq<u16>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<u32> for DropItem<V>where
    V: PartialEq<u32>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<u64> for DropItem<V>where
    V: PartialEq<u64>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialEq<u8> for DropItem<V>where
    V: PartialEq<u8>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, V, T> PartialOrd<&'a [T]> for DropItem<V>where
    V: PartialOrd<&'a [T]>,

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

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

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

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

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

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

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

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

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

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

impl<'a, V> PartialOrd<&'a str> for DropItem<V>where
    V: PartialOrd<&'a str>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<()> for DropItem<V>where
    V: PartialOrd<()>,

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

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

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

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

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

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

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

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

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

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

impl<V: PartialOrd<W>, W> PartialOrd<DropItem<W>> for DropItem<V>

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<bool> for DropItem<V>where
    V: PartialOrd<bool>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<char> for DropItem<V>where
    V: PartialOrd<char>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<f32> for DropItem<V>where
    V: PartialOrd<f32>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<f64> for DropItem<V>where
    V: PartialOrd<f64>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<i128> for DropItem<V>where
    V: PartialOrd<i128>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<i16> for DropItem<V>where
    V: PartialOrd<i16>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<i32> for DropItem<V>where
    V: PartialOrd<i32>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<i64> for DropItem<V>where
    V: PartialOrd<i64>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<i8> for DropItem<V>where
    V: PartialOrd<i8>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<str> for DropItem<V>where
    V: PartialOrd<str>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<u128> for DropItem<V>where
    V: PartialOrd<u128>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<u16> for DropItem<V>where
    V: PartialOrd<u16>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<u32> for DropItem<V>where
    V: PartialOrd<u32>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<u64> for DropItem<V>where
    V: PartialOrd<u64>,

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

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

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

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

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

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

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

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

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

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

impl<V> PartialOrd<u8> for DropItem<V>where
    V: PartialOrd<u8>,

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

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

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

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

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

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

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

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

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

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

impl<V: Eq> Eq for DropItem<V>