Trait otter_api_tests::Index
1.0.0 · source · [−]pub trait Index<Idx> where
Idx: ?Sized, {
type Output: ?Sized;
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);
Associated Types
Required methods
Implementations on Foreign Types
const: unstable · sourceimpl<I> Index<I> for str where
I: SliceIndex<str>,
impl<I> Index<I> for str where
I: SliceIndex<str>,
type Output = <I as SliceIndex<str>>::Output
fn index(&self, index: I) -> &<I as SliceIndex<str>>::Output
1.50.0 (const: unstable) · sourceimpl<T, I, const N: usize> Index<I> for [T; N] where
[T]: Index<I>,
impl<T, I, const N: usize> Index<I> for [T; N] where
[T]: Index<I>,
1.26.0 · sourceimpl Index<RangeToInclusive<usize>> for String
impl Index<RangeToInclusive<usize>> for String
1.26.0 · sourceimpl Index<RangeInclusive<usize>> for String
impl Index<RangeInclusive<usize>> for String
impl<A, I> Index<I> for SmallVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> Index<I> for SmallVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output
fn index(&self, index: I) -> &<I as SliceIndex<[<A as Array>::Item]>>::Output
impl<EntryData> Index<Index<EntryData>> for VecList<EntryData>
impl<EntryData> Index<Index<EntryData>> for VecList<EntryData>
sourceimpl<'a, K, V, T> Index<&'a T> for OrderedMap<K, V> where
T: Eq + PhfHash + ?Sized,
K: PhfBorrow<T>,
impl<'a, K, V, T> Index<&'a T> for OrderedMap<K, V> where
T: Eq + PhfHash + ?Sized,
K: PhfBorrow<T>,
impl<I> Index<I> for UncasedStr where
I: SliceIndex<str, Output = str>,
impl<I> Index<I> for UncasedStr where
I: SliceIndex<str, Output = str>,
impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
Endian: Endianity,
impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
Endian: Endianity,
impl Index<RangeInclusive<usize>> for BStr
impl Index<RangeInclusive<usize>> for BStr
type Output = BStr
fn index(&self, r: RangeInclusive<usize>) -> &BStr
impl Index<RangeToInclusive<usize>> for BStr
impl Index<RangeToInclusive<usize>> for BStr
type Output = BStr
fn index(&self, r: RangeToInclusive<usize>) -> &BStr
impl<A, I> Index<I> for ArrayVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> Index<I> for ArrayVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> Index<I> for TinyVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<A, I> Index<I> for TinyVec<A> where
A: Array,
I: SliceIndex<[<A as Array>::Item]>,
impl<'s, T, I> Index<I> for SliceVec<'s, T> where
I: SliceIndex<[T]>,
impl<'s, T, I> Index<I> for SliceVec<'s, T> where
I: SliceIndex<[T]>,
impl<P, Container> Index<(u32, u32)> for ImageBuffer<P, Container> where
P: Pixel,
Container: Deref<Target = [<P as Pixel>::Subpixel]>,
impl<P, Container> Index<(u32, u32)> for ImageBuffer<P, Container> where
P: Pixel,
Container: Deref<Target = [<P as Pixel>::Subpixel]>,
sourceimpl<'a, K, T> Index<K> for HeaderMap<T> where
K: AsHeaderName,
impl<'a, K, T> Index<K> for HeaderMap<T> where
K: AsHeaderName,
impl Index<RangeInclusive<usize>> for UninitSlice
impl Index<RangeInclusive<usize>> for UninitSlice
type Output = UninitSlice
fn index(&self, index: RangeInclusive<usize>) -> &UninitSlice
impl Index<RangeToInclusive<usize>> for UninitSlice
impl Index<RangeToInclusive<usize>> for UninitSlice
type Output = UninitSlice
fn index(&self, index: RangeToInclusive<usize>) -> &UninitSlice
sourceimpl<K, V, S> Index<usize> for IndexMap<K, V, S>
impl<K, V, S> Index<usize> for IndexMap<K, V, S>
Access IndexMap
values at indexed positions.
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!
sourceimpl<'_, K, V, Q, S> Index<&'_ Q> for IndexMap<K, V, S> where
Q: Hash + Equivalent<K> + ?Sized,
K: Hash + Eq,
S: BuildHasher,
impl<'_, K, V, Q, S> Index<&'_ Q> for IndexMap<K, V, S> where
Q: Hash + Equivalent<K> + ?Sized,
K: Hash + Eq,
S: BuildHasher,
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!
sourceimpl<T, S> Index<usize> for IndexSet<T, S>
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!
impl<'_, K, Q, V, S, A> Index<&'_ Q> for HashMap<K, V, S, A> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
A: Allocator + Clone,
impl<'_, K, Q, V, S, A> Index<&'_ Q> for HashMap<K, V, S, A> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
A: Allocator + Clone,
sourceimpl<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
fn index(&self, index: usize) -> &<T as ForeignType>::Ref
Implementors
sourceimpl<'_, K, Q, V> Index<&'_ Q> for BTreeMap<K, V> where
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
impl<'_, K, Q, V> Index<&'_ Q> for BTreeMap<K, V> where
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
type Output = V
sourceimpl<'_, K, Q, V, S> Index<&'_ Q> for otter_api_tests::shapelib::HashMap<K, V, S> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
impl<'_, K, Q, V, S> Index<&'_ Q> for otter_api_tests::shapelib::HashMap<K, V, S> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
type Output = V
sourceimpl<'a, Q> Index<&'a Q> for otter_api_tests::imports::toml::value::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
impl<'a, Q> Index<&'a Q> for otter_api_tests::imports::toml::value::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
Access an element of this map. Panics if the given key is not present in the map.
sourceimpl<'a, Q> Index<&'a Q> for otter_api_tests::serde_json::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
impl<'a, Q> Index<&'a Q> for otter_api_tests::serde_json::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
Access an element of this map. Panics if the given key is not present in the map.
match *val {
Value::String(ref s) => Some(s.as_str()),
Value::Array(ref arr) => arr[0].as_str(),
Value::Object(ref map) => map["type"].as_str(),
_ => None,
}
impl<'t> Index<usize> for otter_api_tests::imports::regex::bytes::Captures<'t>
impl<'t> Index<usize> for otter_api_tests::imports::regex::bytes::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.
impl<'t> Index<usize> for otter_api_tests::imports::regex::Captures<'t>
impl<'t> Index<usize> for otter_api_tests::imports::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.
impl<'t, 'i> Index<&'i str> for otter_api_tests::imports::regex::bytes::Captures<'t>
impl<'t, 'i> Index<&'i str> for otter_api_tests::imports::regex::bytes::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.
impl<'t, 'i> Index<&'i str> for otter_api_tests::imports::regex::Captures<'t>
impl<'t, 'i> Index<&'i str> for otter_api_tests::imports::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.