Trait otter_nodejs_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);
Required Associated Types
Required Methods
Implementors
impl Index<RangeInclusive<usize>> for BStr
impl Index<RangeInclusive<usize>> for BStr
type Output = BStr
impl Index<RangeInclusive<usize>> for UninitSlice
impl Index<RangeInclusive<usize>> for UninitSlice
type Output = UninitSlice
impl Index<RangeToInclusive<usize>> for BStr
impl Index<RangeToInclusive<usize>> for BStr
type Output = BStr
impl Index<RangeToInclusive<usize>> for UninitSlice
impl Index<RangeToInclusive<usize>> for UninitSlice
type Output = UninitSlice
sourceimpl<'_, K, Q, V, A> Index<&Q> for BTreeMap<K, V, A> where
A: Allocator + Clone,
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
impl<'_, K, Q, V, A> Index<&Q> for BTreeMap<K, V, A> where
A: Allocator + Clone,
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
type Output = V
sourceimpl<'_, K, Q, V, S> Index<&Q> for otter_nodejs_tests::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_nodejs_tests::HashMap<K, V, S> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
type Output = V
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,
type Output = V
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!
type Output = V
sourceimpl<'a, K, T> Index<K> for HeaderMap<T> where
K: AsHeaderName,
impl<'a, K, T> Index<K> for HeaderMap<T> where
K: AsHeaderName,
type Output = T
sourceimpl<'a, K, V, T> Index<&'a T> for phf::map::Map<K, V> where
T: Eq + PhfHash + ?Sized,
K: PhfBorrow<T>,
impl<'a, K, V, T> Index<&'a T> for phf::map::Map<K, V> where
T: Eq + PhfHash + ?Sized,
K: PhfBorrow<T>,
type Output = V
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>,
type Output = V
sourceimpl<'a, Q> Index<&'a Q> for otter_nodejs_tests::otter_support::crates::toml::value::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
impl<'a, Q> Index<&'a Q> for otter_nodejs_tests::otter_support::crates::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_nodejs_tests::tera::Map<String, Value> where
Q: Ord + Eq + Hash + ?Sized,
String: Borrow<Q>,
impl<'a, Q> Index<&'a Q> for otter_nodejs_tests::tera::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<'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<'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]>,
type Output = <I as SliceIndex<[T]>>::Output
impl<'t> Index<usize> for otter_nodejs_tests::lazy_regex::Captures<'t>
impl<'t> Index<usize> for otter_nodejs_tests::lazy_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> Index<usize> for otter_nodejs_tests::regex::bytes::Captures<'t>
impl<'t> Index<usize> for otter_nodejs_tests::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, 'i> Index<&'i str> for otter_nodejs_tests::lazy_regex::Captures<'t>
impl<'t, 'i> Index<&'i str> for otter_nodejs_tests::lazy_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.
impl<'t, 'i> Index<&'i str> for otter_nodejs_tests::regex::bytes::Captures<'t>
impl<'t, 'i> Index<&'i str> for otter_nodejs_tests::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<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]>,
type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output
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
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]>,
type Output = <I as SliceIndex<[<A as Array>::Item]>>::Output
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
impl<I> Index<I> for UncasedStr where
I: SliceIndex<str, Output = str>,
impl<I> Index<I> for UncasedStr where
I: SliceIndex<str, Output = str>,
type Output = UncasedStr
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
type Output = <R as IdxSliceIndex<I, T>>::Output
sourceimpl<I, T, const LANES: usize> Index<I> for Simd<T, LANES> where
T: SimdElement,
I: SliceIndex<[T]>,
LaneCount<LANES>: SupportedLaneCount,
impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES> where
T: SimdElement,
I: SliceIndex<[T]>,
LaneCount<LANES>: SupportedLaneCount,
type Output = <I as SliceIndex<[T]>>::Output
sourceimpl<K, V> Index<K> for HopSlotMap<K, V> where
K: Key,
impl<K, V> Index<K> for HopSlotMap<K, V> where
K: Key,
type Output = V
sourceimpl<K, V> Index<K> for SecondaryMap<K, V> where
K: Key,
impl<K, V> Index<K> for SecondaryMap<K, V> where
K: Key,
type Output = V
sourceimpl<K, V> Index<K> for DenseSlotMap<K, V> where
K: Key,
impl<K, V> Index<K> for DenseSlotMap<K, V> where
K: Key,
type Output = V
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!
type Output = V
sourceimpl<K, V, S> Index<K> for SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
impl<K, V, S> Index<K> for SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
type Output = V
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]>,
type Output = P
sourceimpl<T> Index<OldNewIndex> for OldNew<T>
impl<T> Index<OldNewIndex> for OldNew<T>
type Output = T
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
const: unstable · sourceimpl<T, I> Index<I> for [T] where
I: SliceIndex<[T]>,
impl<T, I> Index<I> for [T] where
I: SliceIndex<[T]>,
type Output = <I as SliceIndex<[T]>>::Output
sourceimpl<T, I, A> Index<I> for Vec<T, A> where
I: SliceIndex<[T]>,
A: Allocator,
impl<T, I, A> Index<I> for Vec<T, A> where
I: SliceIndex<[T]>,
A: Allocator,
type Output = <I as SliceIndex<[T]>>::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>,
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!