Struct WeightedItem 

pub struct WeightedItem<V, W: Weight> {
    pub weight: W,
    pub value: V,
}

An item in a WeightedList, with a value of type V and a weight of numerical type W.

For consistency and layout, weight always comes before value when ordering is relevant. Methods and conversions will expect (W, V), not (V, W).

You should rarely find yourself constructing a WeightedItem by hand – instead, you’ll usually interact with existing instances from a WeightedList.

Fields

weight: W

The weight of the item. A positive number. 0 is technically valid, but not advised.

Notes

• num_traits::Unsigned is not enforced because this is incompatible with non-integer W (f32, f64, etc.) which are always signed.

value: V

The value stored in the item.

Implementations

impl<V, W: Weight> WeightedItem<V, W>

pub fn unit(value: V) -> Self

Construct an item with value and a weight of 1.

pub fn new(weight: W, value: V) -> Self

Construct an item with value and weight.

pub fn from((weight, value): (W, V)) -> Self

Construct an item from a (weight, value) pair.

Trait Implementations

impl<V: Clone, W: Clone + Weight> Clone for WeightedItem<V, W>

fn clone(&self) -> WeightedItem<V, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, W: Debug + Weight> Debug for WeightedItem<V, W>

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

Formats the value using the given formatter.

impl<V, W> Default for WeightedItem<V, W>

where V: Default, W: Default + Weight,

fn default() -> Self

Returns the “default value” for a type.

impl<V, W> Display for WeightedItem<V, W>

where V: Display, W: Display + Weight,

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

Formats the value using the given formatter.

impl<V, W: Weight> Extend<WeightedItem<V, W>> for WeightedList<V, W>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = WeightedItem<V, W>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<V, W: Weight> From<WeightedItem<V, W>> for (W, V)

fn from(item: WeightedItem<V, W>) -> Self

Converts to this type from the input type.

impl<V, W: Weight> FromIterator<WeightedItem<V, W>> for WeightedList<V, W>

fn from_iter<I>(items: I) -> Self

where I: IntoIterator<Item = WeightedItem<V, W>>,

Creates a value from an iterator.

impl<V: Hash, W: Hash + Weight> Hash for WeightedItem<V, W>

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<V, W> Ord for WeightedItem<V, W>

where V: Eq, W: Ord + Weight,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<V: PartialEq, W: PartialEq + Weight> PartialEq for WeightedItem<V, W>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<V, W: Weight> PartialOrd for WeightedItem<V, W>

where V: Eq,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<V: Eq, W: Eq + Weight> Eq for WeightedItem<V, W>

impl<V, W: Weight> StructuralPartialEq for WeightedItem<V, W>