Trait otter_api_tests::Index1.0.0[−][src]

#[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[src]

The returned type after indexing.

Loading content...

Required methods

pub fn index(&self, index: Idx) -> &Self::Output[src]

Performs the indexing (container[index]) operation.

Loading content...

Implementations on Foreign Types

impl Index<RangeFrom<usize>> for CStr[src]

type Output = CStr

impl Index<RangeFull> for OsString[src]

type Output = OsStr

impl Index<RangeFull> for CString[src]

type Output = CStr

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

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

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

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

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

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

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

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

impl Index<Range<usize>> for String[src]

type Output = str

impl Index<RangeTo<usize>> for String[src]

type Output = str

impl Index<RangeFrom<usize>> for String[src]

type Output = str

impl Index<RangeToInclusive<usize>> for String[src]

type Output = str

impl Index<RangeFull> for String[src]

type Output = str

impl Index<RangeInclusive<usize>> for String[src]

type Output = str

impl<T> Index<User> for [T; 2][src]

type Output = T

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

type Output = [u8]

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

type Output = u8

impl<T> Index<usize> for Slab<T>[src]

type Output = T

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<'s, T, I> Index<I> for SliceVec<'s, T> where
    I: SliceIndex<[T]>, 

type Output = <I as SliceIndex<[T]>>::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

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 Index<RangeFrom<Position>> for Url[src]

type Output = str

impl Index<RangeTo<Position>> for Url[src]

type Output = str

impl Index<RangeFull> for Url[src]

type Output = str

impl Index<Range<Position>> for Url[src]

type Output = str

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

type Output = V

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

type Output = V

Loading content...

Implementors

impl Index<Range<Position>> for otter_api_tests::shapelib::Url[src]

type Output = str

impl Index<RangeFrom<Position>> for otter_api_tests::shapelib::Url[src]

type Output = str

impl Index<RangeFull> for otter_api_tests::shapelib::Url[src]

type Output = str

impl Index<RangeTo<Position>> for otter_api_tests::shapelib::Url[src]

type Output = str

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

type Output = V

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

Notable 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: Future + Unpin + ?Sized,  type Output = <F as Future>::Output;
[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
    S: BuildHasher,
    K: Eq + Hash + Borrow<Q>,
    Q: Eq + Hash + ?Sized, [src]

type Output = V

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

Notable 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: Future + Unpin + ?Sized,  type Output = <F as Future>::Output;
[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, Q> Index<&'a Q> for otter_api_tests::imports::toml::value::Map<String, Value> where
    Q: Ord + Eq + Hash + ?Sized,
    String: Borrow<Q>, [src]

Access an element of this map. Panics if the given key is not present in the map.

type Output = Value

impl<'a, Q> Index<&'a Q> for otter_api_tests::serde_json::Map<String, Value> where
    Q: Ord + Eq + Hash + ?Sized,
    String: Borrow<Q>, [src]

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

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

type Output = [u8]

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

type Output = str

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

type Output = [u8]

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

type Output = str

impl<A> Index<usize> for VecDeque<A>[src]

type Output = A

impl<I> Index<I> for otter_api_tests::imports::toml::Value where
    I: Index, [src]

type Output = Value

impl<I> Index<I> for otter_api_tests::serde_json::Value where
    I: Index, [src]

type Output = Value

pub fn index(&self, index: I) -> &Value[src]

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<I, R, T> Index<R> for IndexSlice<I, [T]> where
    R: IdxSliceIndex<I, T>,
    I: Idx, 

type Output = <R as IdxSliceIndex<I, T>>::Output

impl<K, V> Index<K> for HopSlotMap<K, V> where
    K: Key, [src]

type Output = V

impl<K, V> Index<K> for SecondaryMap<K, V> where
    K: Key, [src]

type Output = V

impl<K, V> Index<K> for SlotMap<K, V> where
    K: Key, [src]

type Output = V

impl<K, V> Index<K> for DenseSlotMap<K, V> where
    K: Key, [src]

type Output = V

impl<K, V> Index<K> for EnumMap<K, V> where
    K: Enum<V>, 

type Output = V

impl<K, V, S> Index<K> for SparseSecondaryMap<K, V, S> where
    S: BuildHasher,
    K: Key, [src]

type Output = V

impl<T> Index<OldNewIndex> for OldNew<T>[src]

type Output = T

impl<T, I> Index<I> for Deque<T, I> where
    I: Offset, 

type Output = T

Loading content...