Trait otter_api_tests::IndexMut 1.0.0[−][src]
pub trait IndexMut<Idx>: Index<Idx> where
Idx: ?Sized, { fn index_mut(&mut self, index: Idx) -> &mut Self::Output; }
Expand description
Used for indexing operations (container[index]
) in mutable contexts.
container[index]
is actually syntactic sugar for
*container.index_mut(index)
, but only when used as a mutable value. If
an immutable value is requested, the Index
trait is used instead. This
allows nice things such as v[index] = value
.
Examples
A very simple implementation of a Balance
struct that has two sides, where
each can be indexed mutably and immutably.
use std::ops::{Index, IndexMut}; #[derive(Debug)] enum Side { Left, Right, } #[derive(Debug, PartialEq)] enum Weight { Kilogram(f32), Pound(f32), } struct Balance { pub left: Weight, pub right: Weight, } impl Index<Side> for Balance { type Output = Weight; fn index(&self, index: Side) -> &Self::Output { println!("Accessing {:?}-side of balance immutably", index); match index { Side::Left => &self.left, Side::Right => &self.right, } } } impl IndexMut<Side> for Balance { fn index_mut(&mut self, index: Side) -> &mut Self::Output { println!("Accessing {:?}-side of balance mutably", index); match index { Side::Left => &mut self.left, Side::Right => &mut self.right, } } } let mut balance = Balance { right: Weight::Kilogram(2.5), left: Weight::Pound(1.5), }; // In this case, `balance[Side::Right]` is sugar for // `*balance.index(Side::Right)`, since we are only *reading* // `balance[Side::Right]`, not writing it. assert_eq!(balance[Side::Right], Weight::Kilogram(2.5)); // However, in this case `balance[Side::Left]` is sugar for // `*balance.index_mut(Side::Left)`, since we are writing // `balance[Side::Left]`. balance[Side::Left] = Weight::Kilogram(3.0);
Required methods
Implementations on Foreign Types
impl<A, I> IndexMut<I> for SmallVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> IndexMut<I> for SmallVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
pub fn index_mut(
&mut self,
index: I
) -> &mut <I as SliceIndex<[<A as Array>::Item]>>::Output
impl<'s, T, I> IndexMut<I> for SliceVec<'s, T> where
I: SliceIndex<[T]>,
impl<'s, T, I> IndexMut<I> for SliceVec<'s, T> where
I: SliceIndex<[T]>,
impl<A, I> IndexMut<I> for TinyVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> IndexMut<I> for TinyVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> IndexMut<I> for ArrayVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> IndexMut<I> for ArrayVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl IndexMut<RangeInclusive<usize>> for BStr
impl IndexMut<RangeInclusive<usize>> for BStr
pub fn index_mut(&mut self, r: RangeInclusive<usize>) -> &mut BStr
impl IndexMut<RangeToInclusive<usize>> for BStr
impl IndexMut<RangeToInclusive<usize>> for BStr
pub fn index_mut(&mut self, r: RangeToInclusive<usize>) -> &mut BStr
Access IndexMap
values at indexed positions.
Mutable indexing allows changing / updating indexed values that are already present.
You can not insert new values with index syntax, use .insert()
.
Examples
use indexmap::IndexMap; let mut map = IndexMap::new(); for word in "Lorem ipsum dolor sit amet".split_whitespace() { map.insert(word.to_lowercase(), word.to_string()); } let lorem = &mut map[0]; assert_eq!(lorem, "Lorem"); lorem.retain(char::is_lowercase); assert_eq!(map["lorem"], "orem");
use indexmap::IndexMap; let mut map = IndexMap::new(); map.insert("foo", 1); map[10] = 1; // panics!
impl<'_, K, V, Q, S> IndexMut<&'_ Q> for IndexMap<K, V, S> where
S: BuildHasher,
K: Hash + Eq,
Q: Hash + Equivalent<K> + ?Sized,
[src]
impl<'_, K, V, Q, S> IndexMut<&'_ Q> for IndexMap<K, V, S> where
S: BuildHasher,
K: Hash + Eq,
Q: Hash + Equivalent<K> + ?Sized,
[src]Access IndexMap
values corresponding to a key.
Mutable indexing allows changing / updating values of key-value pairs that are already present.
You can not insert new pairs with index syntax, use .insert()
.
Examples
use indexmap::IndexMap; let mut map = IndexMap::new(); for word in "Lorem ipsum dolor sit amet".split_whitespace() { map.insert(word.to_lowercase(), word.to_string()); } let lorem = &mut map["lorem"]; assert_eq!(lorem, "Lorem"); lorem.retain(char::is_lowercase); assert_eq!(map["lorem"], "orem");
use indexmap::IndexMap; let mut map = IndexMap::new(); map.insert("foo", 1); map["bar"] = 1; // panics!
Implementors
Mutably access an element of this map. Panics if the given key is not present in the map.
Mutably access an element of this map. Panics if the given key is not present in the map.
map["key"] = json!("value");
Write into a serde_json::Value
using the syntax value[0] = ...
or
value["k"] = ...
.
If the index is a number, the value must be an array of length bigger than the index. Indexing into a value that is not an array or an array that is too small will panic.
If the index is a string, the value must be an object or null which is treated like an empty object. If the key is not already present in the object, it will be inserted with a value of null. Indexing into a value that is neither an object nor null will panic.
Examples
let mut data = json!({ "x": 0 }); // replace an existing key data["x"] = json!(1); // insert a new key data["y"] = json!([false, false, false]); // replace an array value data["y"][0] = json!(true); // inserted a deeply nested key data["a"]["b"]["c"]["d"] = json!(true); println!("{}", data);
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
pub fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output