Trait codegame::prelude::Index

#[lang = "index"]pub trait Index<Idx> where
    Idx: ?Sized, {
    type Output: ?Sized;
    pub 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

pub 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

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

impl Index<RangeFrom<usize>> for CStr

type Output = CStr

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

impl Index<RangeFull> for OsString

type Output = OsStr

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

impl<I> Index<I> for str where
    I: SliceIndex<str>, 

type Output = <I as SliceIndex<str>>::Output

pub 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

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

impl<T, I, const N: usize> Index<I> for [T; N] where
    [T]: Index<I>, 

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

pub fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

impl Index<RangeFull> for String

type Output = str

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

impl Index<RangeTo<usize>> for String

type Output = str

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

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

type Output = V

pub 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<T, I, A> Index<I> for Vec<T, A> where
    A: AllocRef,
    I: SliceIndex<[T]>, 

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

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

impl Index<RangeFrom<usize>> for String

type Output = str

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

impl Index<RangeInclusive<usize>> for String

type Output = str

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

impl Index<RangeToInclusive<usize>> for String

type Output = str

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

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

type Output = A

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

impl Index<Range<usize>> for String

type Output = str

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

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

type Output = T

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

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

type Output = V

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

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

type Output = V

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

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

type Output = [u8]

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

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

type Output = u8

pub fn index(
    &self,
    idx: usize
) -> &<EndianSlice<'input, Endian> as Index<usize>>::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

pub fn index(
    &self,
    index: I
) -> &<I as SliceIndex<[<A as Array>::Item]>>::Output

impl Index<usize> for Cursor

type Output = CursorImageBuffer

pub fn index(&self, index: usize) -> &<Cursor as Index<usize>>::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

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

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

type Output = T

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

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

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

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

type Output = T

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

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

type Output = T

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

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

type Output = T

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

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

type Output = T

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

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

type Output = T

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

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

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

pub 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 Index<RangeFrom<Position>> for Url

type Output = str

pub fn index(&self, range: RangeFrom<Position>) -> &str

impl Index<Range<Position>> for Url

type Output = str

pub fn index(&self, range: Range<Position>) -> &str

impl Index<RangeFull> for Url

type Output = str

pub fn index(&self, RangeFull) -> &str

impl Index<RangeTo<Position>> for Url

type Output = str

pub fn index(&self, range: RangeTo<Position>) -> &str

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]pub fn index(&self, index: I) -> &<ArrayVec<A> as Index<I>>::Output

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

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

#[must_use]pub fn index(&self, index: I) -> &<SliceVec<'s, T> 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]pub fn index(&self, index: I) -> &<TinyVec<A> as Index<I>>::Output

Loading content...

Implementors

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

pub 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, Q> Index<&'a Q> for 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

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

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

type Output = Value

pub 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

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

Loading content...