Trait geng_core::prelude::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 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 Index<RangeFull> for OsString

type Output = OsStr

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

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<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 Index<RangeToInclusive<usize>> for String

type Output = str

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

impl Index<RangeFrom<usize>> for String

type Output = str

fn index(&self, index: RangeFrom<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ⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

Returns a reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the BTreeMap.

impl Index<RangeInclusive<usize>> for String

type Output = str

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

impl Index<Range<usize>> for String

type Output = str

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

impl Index<RangeFull> for String

type Output = str

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

impl<A> Index<usize> for VecDeque<A>

type Output = A

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

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

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ⓘ

Important traits for Vec<u8>

impl Write for Vec<u8>

impl Index<RangeTo<usize>> for String

type Output = str

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

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ⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

Returns a reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the HashMap.

impl<'input, Endian> Index<usize> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Output = u8

fn index(
    &self,
    idx: usize
) -> &<EndianSlice<'input, Endian> as Index<usize>>::Output

impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
    Endian: Endianity, 

type Output = [u8]

fn index(
    &self,
    idx: RangeFrom<usize>
) -> &<EndianSlice<'input, Endian> as Index<RangeFrom<usize>>>::Output

impl<T> Index<usize> for Slab<T>

type Output = T

fn index(&self, key: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<'a, V> Index<&'a usize> for VecMap<V>

type Output = V

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

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<V> Index<usize> for VecMap<V>

type Output = V

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

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<'_> Index<&'_ Value> for Map

type Output = Value

fn index(&self, index: &Value) -> &<Map as Index<&'_ Value>>::Output

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<T> Index<usize> for Bgr<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<Buffer> Index<(u8, u32, u32)> for FlatSamples<Buffer> where
    Buffer: Index<usize>, 

type Output = <Buffer as Index<usize>>::Output

fn index(
    &self,
    (u8, u32, u32)
) -> &<FlatSamples<Buffer> as Index<(u8, u32, u32)>>::Output

Return a reference to a single sample at specified coordinates.

Panics

When the coordinates are out of bounds or the index calculation fails.

impl<T> Index<usize> for Rgba<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<T> Index<usize> for Bgra<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<P, Container> Index<(u32, u32)> for ImageBuffer<P, Container> where
    Container: Deref<Target = [<P as Pixel>::Subpixel]>,
    P: Pixel + 'static,
    <P as Pixel>::Subpixel: 'static, 

type Output = P

fn index(&self, (u32, u32)) -> &Pⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<T> Index<usize> for Rgb<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<T> Index<usize> for Luma<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<T> Index<usize> for LumaA<T> where
    T: Primitive, 

type Output = T

fn index(&self, _index: usize) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

impl<'a, K, V, S, Q> Index<&'a Q> for LinkedHashMap<K, V, S> where
    K: Hash + Eq + Borrow<Q>,
    Q: Eq + Hash + ?Sized,
    S: BuildHasher, 

type Output = V

fn index(&self, index: &'a Q) -> &Vⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

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

#[must_use]fn index(&self, index: I) -> &<ArrayVec<A> as Index<I>>::Output

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

#[must_use]fn index(&self, index: I) -> &<TinyVec<A> as Index<I>>::Output

Loading content...

Implementors

impl<'_, K, Q, V, S> Index<&'_ Q> for geng_core::prelude::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ⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

Returns a reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the HashMap.

impl<'a, Q> Index<&'a Q> for geng_core::prelude::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,
}

type Output = Value

fn index(&self, index: &Q) -> &Value

impl<I> Index<I> for Value where
    I: Index, 

type Output = Value

fn index(&self, index: I) -> &Value

Index into a serde_json::Value using the syntax value[0] or value["k"].

Returns Value::Null if the type of self does not match the type of the index, for example if the index is a string and self is an array or a number. Also returns Value::Null if the given key does not exist in the map or the given index is not within the bounds of the array.

For retrieving deeply nested values, you should have a look at the Value::pointer method.

Examples

let data = json!({
    "x": {
        "y": ["z", "zz"]
    }
});

assert_eq!(data["x"]["y"], json!(["z", "zz"]));
assert_eq!(data["x"]["y"][0], json!("z"));

assert_eq!(data["a"], json!(null)); // returns null for undefined values
assert_eq!(data["a"]["b"], json!(null)); // does not panic

impl<T> Index<(usize, usize)> for Mat4<T>

type Output = T

fn index(&self, (usize, usize)) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

Loading content...