pub trait Index<Idx>where
Idx: ?Sized,{
type Output: ?Sized;
// Required method
fn index(&self, index: Idx) -> &Self::Output;
}Expand description
Used for indexing operations (container[index]) in immutable contexts.
container[index] is actually syntactic sugar for *container.index(index),
but only when used as an immutable value. If a mutable value is requested,
IndexMut is used instead. This allows nice things such as
let value = v[index] if the type of value implements Copy.
§Examples
The following example implements Index on a read-only NucleotideCount
container, enabling individual counts to be retrieved with index syntax.
use std::ops::Index;
enum Nucleotide {
A,
C,
G,
T,
}
struct NucleotideCount {
a: usize,
c: usize,
g: usize,
t: usize,
}
impl Index<Nucleotide> for NucleotideCount {
type Output = usize;
fn index(&self, nucleotide: Nucleotide) -> &Self::Output {
match nucleotide {
Nucleotide::A => &self.a,
Nucleotide::C => &self.c,
Nucleotide::G => &self.g,
Nucleotide::T => &self.t,
}
}
}
let nucleotide_count = NucleotideCount {a: 14, c: 9, g: 10, t: 12};
assert_eq!(nucleotide_count[Nucleotide::A], 14);
assert_eq!(nucleotide_count[Nucleotide::C], 9);
assert_eq!(nucleotide_count[Nucleotide::G], 10);
assert_eq!(nucleotide_count[Nucleotide::T], 12);Required Associated Types§
Required Methods§
Implementors§
Source§impl Index<&str> for Dictionary
Access an element of this dictionary. Panics if the given key is not present in the dictionary.
impl Index<&str> for Dictionary
Access an element of this dictionary. Panics if the given key is not present in the dictionary.
match *val {
Value::Array(ref arr) => arr[0].as_string(),
Value::Dictionary(ref dict) => dict["type"].as_string(),
Value::String(ref s) => Some(s.as_str()),
_ => None,
}Source§impl Index<Range<usize>> for UninitSlice
impl Index<Range<usize>> for UninitSlice
type Output = UninitSlice
Source§impl Index<RangeFrom<usize>> for UninitSlice
impl Index<RangeFrom<usize>> for UninitSlice
type Output = UninitSlice
Source§impl Index<RangeFull> for UninitSlice
impl Index<RangeFull> for UninitSlice
type Output = UninitSlice
Source§impl Index<RangeInclusive<usize>> for ByteString
impl Index<RangeInclusive<usize>> for ByteString
Source§impl Index<RangeInclusive<usize>> for UninitSlice
impl Index<RangeInclusive<usize>> for UninitSlice
type Output = UninitSlice
Source§impl Index<RangeTo<usize>> for UninitSlice
impl Index<RangeTo<usize>> for UninitSlice
type Output = UninitSlice
Source§impl Index<RangeToInclusive<usize>> for ByteString
impl Index<RangeToInclusive<usize>> for ByteString
Source§impl Index<RangeToInclusive<usize>> for UninitSlice
impl Index<RangeToInclusive<usize>> for UninitSlice
type Output = UninitSlice
Source§impl<'a, K, V, S, Q> Index<&'a Q> for LinkedHashMap<K, V, S>
impl<'a, K, V, S, Q> Index<&'a Q> for LinkedHashMap<K, V, S>
Source§impl<'h> Index<usize> for regex::regex::bytes::Captures<'h>
Get a matching capture group’s haystack substring by index.
impl<'h> Index<usize> for regex::regex::bytes::Captures<'h>
Get a matching capture group’s haystack substring by index.
The haystack substring returned can’t outlive the Captures object if this
method is used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it). To work around this limitation, do that, use
Captures::get instead.
'h is the lifetime of the matched haystack, but the lifetime of the
&str returned by this implementation is the lifetime of the Captures
value itself.
§Panics
If there is no matching group at the given index.
Source§impl<'h> Index<usize> for regex::regex::string::Captures<'h>
Get a matching capture group’s haystack substring by index.
impl<'h> Index<usize> for regex::regex::string::Captures<'h>
Get a matching capture group’s haystack substring by index.
The haystack substring returned can’t outlive the Captures object if this
method is used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it). To work around this limitation, do that, use
Captures::get instead.
'h is the lifetime of the matched haystack, but the lifetime of the
&str returned by this implementation is the lifetime of the Captures
value itself.
§Panics
If there is no matching group at the given index.
Source§impl<'h, 'n> Index<&'n str> for regex::regex::bytes::Captures<'h>
Get a matching capture group’s haystack substring by name.
impl<'h, 'n> Index<&'n str> for regex::regex::bytes::Captures<'h>
Get a matching capture group’s haystack substring by name.
The haystack substring returned can’t outlive the Captures object if this
method is used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it). To work around this limitation, do that, use
Captures::name instead.
'h is the lifetime of the matched haystack, but the lifetime of the
&str returned by this implementation is the lifetime of the Captures
value itself.
'n is the lifetime of the group name used to index the Captures value.
§Panics
If there is no matching group at the given name.
Source§impl<'h, 'n> Index<&'n str> for regex::regex::string::Captures<'h>
Get a matching capture group’s haystack substring by name.
impl<'h, 'n> Index<&'n str> for regex::regex::string::Captures<'h>
Get a matching capture group’s haystack substring by name.
The haystack substring returned can’t outlive the Captures object if this
method is used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it). To work around this limitation, do that, use
Captures::name instead.
'h is the lifetime of the matched haystack, but the lifetime of the
&str returned by this implementation is the lifetime of the Captures
value itself.
'n is the lifetime of the group name used to index the Captures value.
§Panics
If there is no matching group at the given name.
Source§impl<'t> Index<usize> for fancy_regex::Captures<'t>
Get a group by index.
impl<'t> Index<usize> for fancy_regex::Captures<'t>
Get a group by index.
't is the lifetime of the matched text.
The text can’t outlive the Captures object if this method is
used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it); to do that, use get() instead.
§Panics
If there is no group at the given index.
Source§impl<'t, 'i> Index<&'i str> for fancy_regex::Captures<'t>
Get a group by name.
impl<'t, 'i> Index<&'i str> for fancy_regex::Captures<'t>
Get a group by name.
't is the lifetime of the matched text and 'i is the lifetime
of the group name (the index).
The text can’t outlive the Captures object if this method is
used, because of how Index is defined (normally a[i] is part
of a and can’t outlive it); to do that, use name instead.
§Panics
If there is no group named by the given value.
Source§impl<K, V> Index<usize> for indexmap::map::iter::Keys<'_, K, V>
Access IndexMap keys at indexed positions.
impl<K, V> Index<usize> for indexmap::map::iter::Keys<'_, K, V>
Access IndexMap keys at indexed positions.
While Index<usize> for IndexMap accesses a map’s values,
indexing through IndexMap::keys offers an alternative to access a map’s
keys instead.
Since Keys is also an iterator, consuming items from the iterator will
offset the effective indices. Similarly, if Keys is obtained from
Slice::keys, indices will be interpreted relative to the position of
that slice.
§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_uppercase());
}
assert_eq!(map[0], "LOREM");
assert_eq!(map.keys()[0], "lorem");
assert_eq!(map[1], "IPSUM");
assert_eq!(map.keys()[1], "ipsum");
map.reverse();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "sit");
map.sort_keys();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "dolor");
// Advancing the iterator will offset the indexing
let mut keys = map.keys();
assert_eq!(keys[0], "amet");
assert_eq!(keys.next().map(|s| &**s), Some("amet"));
assert_eq!(keys[0], "dolor");
assert_eq!(keys[1], "ipsum");
// Slices may have an offset as well
let slice = &map[2..];
assert_eq!(slice[0], "IPSUM");
assert_eq!(slice.keys()[0], "ipsum");use indexmap::IndexMap;
let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map.keys()[10]); // panics!Source§impl<K, V> Index<usize> for ringmap::map::iter::Keys<'_, K, V>
Access RingMap keys at indexed positions.
impl<K, V> Index<usize> for ringmap::map::iter::Keys<'_, K, V>
Access RingMap keys at indexed positions.
While Index<usize> for RingMap accesses a map’s values,
indexing through RingMap::keys offers an alternative to access a map’s
keys instead.
Since Keys is also an iterator, consuming items from the iterator will
offset the effective indices. Similarly, if Keys is obtained from
Slice::keys, indices will be interpreted relative to the position of
that slice.
§Examples
use ringmap::RingMap;
let mut map = RingMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map[0], "LOREM");
assert_eq!(map.keys()[0], "lorem");
assert_eq!(map[1], "IPSUM");
assert_eq!(map.keys()[1], "ipsum");
map.reverse();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "sit");
map.sort_keys();
assert_eq!(map.keys()[0], "amet");
assert_eq!(map.keys()[1], "dolor");
// Advancing the iterator will offset the indexing
let mut keys = map.keys();
assert_eq!(keys[0], "amet");
assert_eq!(keys.next().map(|s| &**s), Some("amet"));
assert_eq!(keys[0], "dolor");
assert_eq!(keys[1], "ipsum");
// Slices may have an offset as well
let (head, tail) = map.as_slices();
assert!(tail.is_empty());
let slice = &head[2..];
assert_eq!(slice[0], "IPSUM");
assert_eq!(slice.keys()[0], "ipsum");use ringmap::RingMap;
let mut map = RingMap::new();
map.insert("foo", 1);
println!("{:?}", map.keys()[10]); // panics!Source§impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>
Access IndexMap values corresponding to a key.
impl<K, V, Q, S> Index<&Q> for IndexMap<K, V, S>
Access IndexMap values corresponding to a key.
§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_uppercase());
}
assert_eq!(map["lorem"], "LOREM");
assert_eq!(map["ipsum"], "IPSUM");use indexmap::IndexMap;
let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map["bar"]); // panics!Source§impl<K, V, Q, S> Index<&Q> for RingMap<K, V, S>
Access RingMap values corresponding to a key.
impl<K, V, Q, S> Index<&Q> for RingMap<K, V, S>
Access RingMap values corresponding to a key.
§Examples
use ringmap::RingMap;
let mut map = RingMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map["lorem"], "LOREM");
assert_eq!(map["ipsum"], "IPSUM");use ringmap::RingMap;
let mut map = RingMap::new();
map.insert("foo", 1);
println!("{:?}", map["bar"]); // panics!Source§impl<K, V, S> Index<usize> for IndexMap<K, V, S>
Access IndexMap values at indexed positions.
impl<K, V, S> Index<usize> for IndexMap<K, V, S>
Access IndexMap values at indexed positions.
See Index<usize> for Keys to access a map’s keys instead.
§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_uppercase());
}
assert_eq!(map[0], "LOREM");
assert_eq!(map[1], "IPSUM");
map.reverse();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "SIT");
map.sort_keys();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "DOLOR");use indexmap::IndexMap;
let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map[10]); // panics!Source§impl<K, V, S> Index<usize> for RingMap<K, V, S>
Access RingMap values at indexed positions.
impl<K, V, S> Index<usize> for RingMap<K, V, S>
Access RingMap values at indexed positions.
See Index<usize> for Keys to access a map’s keys instead.
§Examples
use ringmap::RingMap;
let mut map = RingMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map[0], "LOREM");
assert_eq!(map[1], "IPSUM");
map.reverse();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "SIT");
map.sort_keys();
assert_eq!(map[0], "AMET");
assert_eq!(map[1], "DOLOR");use ringmap::RingMap;
let mut map = RingMap::new();
map.insert("foo", 1);
println!("{:?}", map[10]); // panics!Source§impl<Q> Index<&Q> for Map<String, Value>
Access an element of this map. Panics if the given key is not present in the
map.
impl<Q> Index<&Q> for Map<String, Value>
Access an element of this map. Panics if the given key is not present in the map.
match val {
Value::String(s) => Some(s.as_str()),
Value::Array(arr) => arr[0].as_str(),
Value::Object(map) => map["type"].as_str(),
_ => None,
}Source§impl<T> Index<usize> for StackRef<T>where
T: Stackable,
impl<T> Index<usize> for StackRef<T>where
T: Stackable,
type Output = <T as ForeignType>::Ref
Source§impl<T, F> Index<usize> for VarZeroSlice<T, F>
impl<T, F> Index<usize> for VarZeroSlice<T, F>
Source§impl<T, S> Index<usize> for IndexSet<T, S>
Access IndexSet values at indexed positions.
impl<T, S> Index<usize> for IndexSet<T, S>
Access IndexSet values at indexed positions.
§Examples
use indexmap::IndexSet;
let mut set = IndexSet::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
set.insert(word.to_string());
}
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "ipsum");
set.reverse();
assert_eq!(set[0], "amet");
assert_eq!(set[1], "sit");
set.sort();
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "amet");use indexmap::IndexSet;
let mut set = IndexSet::new();
set.insert("foo");
println!("{:?}", set[10]); // panics!Source§impl<T, S> Index<usize> for RingSet<T, S>
Access RingSet values at indexed positions.
impl<T, S> Index<usize> for RingSet<T, S>
Access RingSet values at indexed positions.
§Examples
use ringmap::RingSet;
let mut set = RingSet::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
set.insert(word.to_string());
}
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "ipsum");
set.reverse();
assert_eq!(set[0], "amet");
assert_eq!(set[1], "sit");
set.sort();
assert_eq!(set[0], "Lorem");
assert_eq!(set[1], "amet");use ringmap::RingSet;
let mut set = RingSet::new();
set.insert("foo");
println!("{:?}", set[10]); // panics!