Trait nom::lib::std::ops::Index

#[lang = "index"]pub trait Index<Idx> where
    Idx: ?Sized, {
    type Output: ?Sized;
    fn index(&self, index: Idx) -> &Self::Output;
}

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

type Output: ?Sized

The returned type after indexing.

Loading content...

Required methods

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

Loading content...

Implementations on Foreign Types

impl Index<RangeFull> for OsString

type Output = OsStr

fn index(&self, _index: RangeFull) -> &OsStr

impl Index<RangeFull> for CString

type Output = CStr

fn index(&self, _index: RangeFull) -> &CStr

impl Index<RangeFrom<usize>> for CStr

type Output = CStr

fn index(&self, index: RangeFrom<usize>) -> &CStr

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

impl<T, I> Index<I> for [T] where
    I: SliceIndex<[T]>, 

type Output = <I as SliceIndex<[T]>>::Output

fn index(&self, index: I) -> &<I as SliceIndex<[T]>>::Output

impl<O, T> Index<Range<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: Range<usize>
) -> &<BitSlice<O, T> as Index<Range<usize>>>::Output

impl<O, T, Idx> Index<Idx> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: Index<Idx>, 

type Output = <BitSlice<O, T> as Index<Idx>>::Output

fn index(&self, index: Idx) -> &<BitVec<O, T> as Index<Idx>>::Output

impl<O, T> Index<RangeInclusive<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: RangeInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeInclusive<usize>>>::Output

impl<O, T> Index<RangeFrom<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: RangeFrom<usize>
) -> &<BitSlice<O, T> as Index<RangeFrom<usize>>>::Output

impl<O, T> Index<RangeTo<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: RangeTo<usize>
) -> &<BitSlice<O, T> as Index<RangeTo<usize>>>::Output

impl<O, T> Index<RangeFull> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: RangeFull
) -> &<BitSlice<O, T> as Index<RangeFull>>::Output

impl<O, T, Idx> Index<Idx> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: Index<Idx>, 

type Output = <BitSlice<O, T> as Index<Idx>>::Output

fn index(&self, index: Idx) -> &<BitBox<O, T> as Index<Idx>>::Output

impl<O, V, Idx> Index<Idx> for BitArray<O, V> where
    O: BitOrder,
    V: BitView,
    BitSlice<O, <V as BitView>::Store>: Index<Idx>, 

type Output = <BitSlice<O, <V as BitView>::Store> as Index<Idx>>::Output

fn index(&self, index: Idx) -> &<BitArray<O, V> as Index<Idx>>::Output

impl<O, T> Index<usize> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = bool

fn index(&self, index: usize) -> &<BitSlice<O, T> as Index<usize>>::Output

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<O, T> Index<RangeToInclusive<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

fn index(
    &self,
    index: RangeToInclusive<usize>
) -> &<BitSlice<O, T> as Index<RangeToInclusive<usize>>>::Output

impl<'t> Index<usize> for 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.

type Output = str

fn index(&self, i: usize) -> &str

impl<'t> Index<usize> for 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.

type Output = [u8]

fn index(&self, i: usize) -> &[u8]

impl<'t, 'i> Index<&'i str> for 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.

type Output = [u8]

fn index(&'a self, name: &'i str) -> &'a [u8]

impl<'t, 'i> Index<&'i str> for 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.

type Output = str

fn index(&'a self, name: &'i str) -> &'a str

Loading content...

Implementors

impl Index<Range<usize>> for String

type Output = str

fn index(&self, index: Range<usize>) -> &str

impl Index<RangeFrom<usize>> for String

type Output = str

fn index(&self, index: RangeFrom<usize>) -> &str

impl Index<RangeFull> for String

type Output = str

fn index(&self, _index: RangeFull) -> &str

impl Index<RangeInclusive<usize>> for String

type Output = str

fn index(&self, index: RangeInclusive<usize>) -> &str

impl Index<RangeTo<usize>> for String

type Output = str

fn index(&self, index: RangeTo<usize>) -> &str

impl Index<RangeToInclusive<usize>> for String

type Output = str

fn index(&self, index: RangeToInclusive<usize>) -> &str

impl<'_, K, Q, V> Index<&'_ Q> for BTreeMap<K, V> where
    K: Ord + Borrow<Q>,
    Q: Ord + ?Sized, 

type Output = V

fn index(&self, key: &Q) -> &V

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, 

type Output = V

fn index(&self, key: &Q) -> &V

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>

type Output = A

fn index(&self, index: usize) -> &A

impl<T, I> Index<I> for Vec<T> where
    I: SliceIndex<[T]>, 

type Output = <I as SliceIndex<[T]>>::Output

fn index(&self, index: I) -> &<Vec<T> as Index<I>>::Output

Loading content...