Trait nom::lib::std::ops::Index 1.0.0[−][src]
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
Loading content...Required methods
pub fn index(&self, index: Idx) -> &Self::Output
[src]
Performs the indexing (container[index]
) operation.
Implementations on Foreign Types
impl Index<RangeFull> for OsString
[src]
impl Index<RangeFrom<usize>> for CStr
[src]
impl Index<RangeFull> for CString
[src]
impl<I> Index<I> for str where
I: SliceIndex<str>,
[src]
I: SliceIndex<str>,
type Output = <I as SliceIndex<str>>::Output
pub fn index(&self, index: I) -> &<I as SliceIndex<str>>::Output
[src]
impl<T, I, const N: usize> Index<I> for [T; N] where
[T]: Index<I>,
[src]
[T]: Index<I>,
type Output = <[T] as Index<I>>::Output
pub fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output
[src]
impl<T, I> Index<I> for [T] where
I: SliceIndex<[T]>,
[src]
I: SliceIndex<[T]>,
type Output = <I as SliceIndex<[T]>>::Output
pub fn index(&self, index: I) -> &<I as SliceIndex<[T]>>::Output
[src]
impl<O, T> Index<RangeToInclusive<usize>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: RangeToInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeToInclusive<usize>>>::Output
[src]
&self,
index: RangeToInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeToInclusive<usize>>>::Output
impl<O, T> Index<RangeInclusive<usize>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: RangeInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeInclusive<usize>>>::Output
[src]
&self,
index: RangeInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeInclusive<usize>>>::Output
impl<O, T> Index<RangeTo<usize>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: RangeTo<usize>
) -> &<BitSlice<O, T> as Index<RangeTo<usize>>>::Output
[src]
&self,
index: RangeTo<usize>
) -> &<BitSlice<O, T> as Index<RangeTo<usize>>>::Output
impl<O, T> Index<RangeFrom<usize>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: RangeFrom<usize>
) -> &<BitSlice<O, T> as Index<RangeFrom<usize>>>::Output
[src]
&self,
index: RangeFrom<usize>
) -> &<BitSlice<O, T> as Index<RangeFrom<usize>>>::Output
impl<O, T, Idx> Index<Idx> for BitBox<O, T> where
O: BitOrder,
T: BitStore,
BitSlice<O, T>: Index<Idx>,
[src]
O: BitOrder,
T: BitStore,
BitSlice<O, T>: Index<Idx>,
type Output = <BitSlice<O, T> as Index<Idx>>::Output
pub fn index(&self, index: Idx) -> &<BitBox<O, T> as Index<Idx>>::Output
[src]
impl<O, T> Index<Range<usize>> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: Range<usize>
) -> &<BitSlice<O, T> as Index<Range<usize>>>::Output
[src]
&self,
index: Range<usize>
) -> &<BitSlice<O, T> as Index<Range<usize>>>::Output
impl<O, T> Index<RangeFull> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = BitSlice<O, T>
pub fn index(
&self,
index: RangeFull
) -> &<BitSlice<O, T> as Index<RangeFull>>::Output
[src]
&self,
index: RangeFull
) -> &<BitSlice<O, T> as Index<RangeFull>>::Output
impl<O, V, Idx> Index<Idx> for BitArray<O, V> where
O: BitOrder,
V: BitView,
BitSlice<O, <V as BitView>::Store>: Index<Idx>,
[src]
O: BitOrder,
V: BitView,
BitSlice<O, <V as BitView>::Store>: Index<Idx>,
type Output = <BitSlice<O, <V as BitView>::Store> as Index<Idx>>::Output
pub fn index(&self, index: Idx) -> &<BitArray<O, V> as Index<Idx>>::Output
[src]
impl<O, T, Idx> Index<Idx> for BitVec<O, T> where
O: BitOrder,
T: BitStore,
BitSlice<O, T>: Index<Idx>,
[src]
O: BitOrder,
T: BitStore,
BitSlice<O, T>: Index<Idx>,
type Output = <BitSlice<O, T> as Index<Idx>>::Output
pub fn index(&self, index: Idx) -> &<BitVec<O, T> as Index<Idx>>::Output
[src]
impl<O, T> Index<usize> for BitSlice<O, T> where
O: BitOrder,
T: BitStore,
[src]
O: BitOrder,
T: BitStore,
type Output = bool
pub fn index(&self, index: usize) -> &<BitSlice<O, T> as Index<usize>>::Output
[src]
Looks up a single bit by semantic index.
Examples
use bitvec::prelude::*; let bits = bits![Msb0, u8; 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]; assert!(!bits[7]); // --------------------------^ | | assert!( bits[8]); // -----------------------------^ | assert!(!bits[9]); // --------------------------------^
If the index is greater than or equal to the length, indexing will panic.
The below test will panic when accessing index 1, as only index 0 is valid.
use bitvec::prelude::*; let bits = bits![0, ]; bits[1]; // --------^
impl<'t, 'i> Index<&'i str> for Captures<'t>
[src]
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> Index<usize> for Captures<'t>
[src]
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 Captures<'t>
[src]
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 Captures<'t>
[src]
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.
Implementors
impl Index<Range<usize>> for String
[src]
impl Index<RangeFrom<usize>> for String
[src]
impl Index<RangeFull> for String
[src]
impl Index<RangeInclusive<usize>> for String
1.26.0[src]
impl Index<RangeTo<usize>> for String
[src]
impl Index<RangeToInclusive<usize>> for String
1.26.0[src]
impl<'_, K, Q, V> Index<&'_ Q> for BTreeMap<K, V> where
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
[src]
K: Borrow<Q> + Ord,
Q: Ord + ?Sized,
type Output = V
pub fn index(&self, key: &Q) -> &Vⓘ
[src]
Returns a reference to the value corresponding to the supplied key.
Panics
Panics if the key is not present in the BTreeMap
.
impl<'_, K, Q, V, S> Index<&'_ Q> for HashMap<K, V, S> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
[src]
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash + ?Sized,
S: BuildHasher,
type Output = V
pub fn index(&self, key: &Q) -> &Vⓘ
[src]
Returns a reference to the value corresponding to the supplied key.
Panics
Panics if the key is not present in the HashMap
.
impl<A> Index<usize> for VecDeque<A>
[src]
impl<T, I, A> Index<I> for Vec<T, A> where
I: SliceIndex<[T]>,
A: Allocator,
[src]
I: SliceIndex<[T]>,
A: Allocator,