1.0.0[−][src]Trait af_lib::prelude::af_core::test::prelude::IndexMut
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
pub fn index_mut(&mut self, index: Idx) -> &mut Self::Output
[src]
Performs the mutable indexing (container[index]
) operation.
Implementations on Foreign Types
impl IndexMut<RangeFull> for OsString
[src]
impl<I> IndexMut<I> for str where
I: SliceIndex<str>,
[src]
I: SliceIndex<str>,
pub fn index_mut(&mut self, index: I) -> &mut <I as SliceIndex<str>>::Output
[src]
impl<T, I> IndexMut<I> for [T] where
I: SliceIndex<[T]>,
[src]
I: SliceIndex<[T]>,
impl<T, I, const N: usize> IndexMut<I> for [T; N] where
[T]: IndexMut<I>,
[src]
[T]: IndexMut<I>,
impl IndexMut<RangeToInclusive<usize>> for String
[src]
pub fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str
[src]
impl IndexMut<RangeFrom<usize>> for String
[src]
impl IndexMut<RangeFull> for String
[src]
impl IndexMut<RangeInclusive<usize>> for String
[src]
pub fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str
[src]
impl IndexMut<Range<usize>> for String
[src]
impl<T, I, A> IndexMut<I> for Vec<T, A> where
A: Allocator,
I: SliceIndex<[T]>,
[src]
A: Allocator,
I: SliceIndex<[T]>,
impl<A> IndexMut<usize> for VecDeque<A>
[src]
pub fn index_mut(&mut self, index: usize) -> &mut AⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl IndexMut<RangeTo<usize>> for String
[src]
impl<A, I> IndexMut<I> for SmallVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
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
&mut self,
index: I
) -> &mut <I as SliceIndex<[<A as Array>::Item]>>::Output
impl IndexMut<RangeToInclusive<usize>> for UninitSlice
[src]
pub fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut UninitSlice
[src]
impl IndexMut<Range<usize>> for UninitSlice
[src]
pub fn index_mut(&mut self, index: Range<usize>) -> &mut UninitSlice
[src]
impl IndexMut<RangeFrom<usize>> for UninitSlice
[src]
pub fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut UninitSlice
[src]
impl IndexMut<RangeInclusive<usize>> for UninitSlice
[src]
pub fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut UninitSlice
[src]
impl IndexMut<RangeTo<usize>> for UninitSlice
[src]
pub fn index_mut(&mut self, index: RangeTo<usize>) -> &mut UninitSlice
[src]
impl IndexMut<RangeFull> for UninitSlice
[src]
pub fn index_mut(&mut self, index: RangeFull) -> &mut UninitSlice
[src]
impl<'s, T, I> IndexMut<I> for SliceVec<'s, T> where
I: SliceIndex<[T]>,
I: SliceIndex<[T]>,
impl<A, I> IndexMut<I> for TinyVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
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]>,
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<'a, BK, K, V> IndexMut<&'a BK> for OrdMap<K, V> where
V: Clone,
K: Ord + Clone + Borrow<BK>,
BK: Ord + ?Sized,
V: Clone,
K: Ord + Clone + Borrow<BK>,
BK: Ord + ?Sized,
impl<'a, BK, K, V, S> IndexMut<&'a BK> for HashMap<K, V, S> where
V: Clone,
S: BuildHasher,
K: Hash + Eq + Clone + Borrow<BK>,
BK: Hash + Eq + ?Sized,
V: Clone,
S: BuildHasher,
K: Hash + Eq + Clone + Borrow<BK>,
BK: Hash + Eq + ?Sized,
impl<A> IndexMut<usize> for Vector<A> where
A: Clone,
A: Clone,
pub fn index_mut(
&mut self,
index: usize
) -> &mut <Vector<A> as Index<usize>>::Output
&mut self,
index: usize
) -> &mut <Vector<A> as Index<usize>>::Output
Get a mutable reference to the value at index index
in the
vector.
Time: O(log n)
impl<A, N, I> IndexMut<I> for Chunk<A, N> where
N: ChunkLength<A>,
I: SliceIndex<[A]>,
N: ChunkLength<A>,
I: SliceIndex<[A]>,
impl<A, N> IndexMut<usize> for SparseChunk<A, N> where
N: ChunkLength<A> + Bits,
N: ChunkLength<A> + Bits,
impl<T> IndexMut<usize> for Arena<T>
pub fn index_mut(&mut self, index: usize) -> &mut TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<T> IndexMut<usize> for StackRef<T> where
T: Stackable,
[src]
T: Stackable,
pub fn index_mut(&mut self, index: usize) -> &mut <T as ForeignType>::Ref
[src]
impl<T> IndexMut<usize> for Slab<T>
[src]
pub fn index_mut(&mut self, key: usize) -> &mut TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<A> IndexMut<RangeFrom<usize>> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
impl<A> IndexMut<Range<usize>> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
impl<A> IndexMut<RangeTo<usize>> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
impl<A> IndexMut<RangeFull> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
impl<K, V, S> IndexMut<usize> for IndexMap<K, V, S>
[src]
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!
pub fn index_mut(&mut self, index: usize) -> &mut VⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
Returns a mutable reference to the value at the supplied index
.
Panics if index
is out of bounds.
impl<'_, K, V, Q, S> IndexMut<&'_ Q> for IndexMap<K, V, S> where
S: BuildHasher,
Q: Hash + Equivalent<K> + ?Sized,
K: Hash + Eq,
[src]
S: BuildHasher,
Q: Hash + Equivalent<K> + ?Sized,
K: Hash + Eq,
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!
pub fn index_mut(&mut self, key: &Q) -> &mut VⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
Returns a mutable reference to the value corresponding to the supplied key
.
Panics if key
is not present in the map.
Implementors
impl<'a, Q> IndexMut<&'a Q> for Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
[src]
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
Mutably access an element of this map. Panics if the given key is not present in the map.
map["key"] = json!("value");
impl<I> IndexMut<I> for Value where
I: Index,
[src]
I: Index,
pub fn index_mut(&mut self, index: I) -> &mut Value
[src]
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);