Struct EntryMut 

pub struct EntryMut<'a, N: Ord + Clone, D> { /* private fields */ }

A find_mut query on the interval tree does not directly return references to the nodes in the tree, but wraps the fields interval and data in an EntryMut. Only the data part can be mutably accessed using the data method

Implementations

impl<'a, N: Ord + Clone + 'a, D: 'a> EntryMut<'a, N, D>

pub fn data(&'a mut self) -> &'a mut D

Get a mutable reference to the data for this entry

pub fn interval(&self) -> &'a Interval<N>

Get a reference to the interval for this entry

Trait Implementations

impl<'a, N: Debug + Ord + Clone, D: Debug> Debug for EntryMut<'a, N, D>

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

Formats the value using the given formatter.

impl<'a, N: Hash + Ord + Clone, D: Hash> Hash for EntryMut<'a, N, D>

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, N: PartialEq + Ord + Clone, D: PartialEq> PartialEq for EntryMut<'a, N, D>

fn eq(&self, other: &EntryMut<'a, N, D>) -> 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<'a, N, D> Serialize for EntryMut<'a, N, D>

where N: Serialize + Ord + Clone, D: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, N: Eq + Ord + Clone, D: Eq> Eq for EntryMut<'a, N, D>

impl<'a, N: Ord + Clone, D> StructuralPartialEq for EntryMut<'a, N, D>