Struct params::Map

pub struct Map(pub BTreeMap<String, Value>);

A type that maps keys to request parameter values.

Methods

impl Map

fn new() -> Map

Creates an empty map.

fn assign(&mut self, path: &str, value: Value) -> Result<(), ParamsError>

Inserts a parameter value to the specified key path.

Key paths are a series of values starting with a plain name and followed by zero or more array-like indices. name is "the value called name", names[] is "the array called names", pts[][x] and pts[][y] are the x and y values of a map at the end of an array.

This method is used during the internal parsing processes and is only made public in the name of hypothetical extensibility.

Examples

let mut map = Map::new();
map.assign("name", Value::String("Callie".into())).unwrap();
assert_eq!(format!("{:?}", map), r#"{"name": "Callie"}"#);

let mut map = Map::new();
map.assign("names[]", Value::String("Anne".into())).unwrap();
map.assign("names[]", Value::String("Bob".into())).unwrap();
assert_eq!(format!("{:?}", map), r#"{"names": ["Anne", "Bob"]}"#);

let mut map = Map::new();
map.assign("pts[][x]", Value::I64(3)).unwrap();
map.assign("pts[][y]", Value::I64(9)).unwrap();
assert_eq!(format!("{:?}", map), r#"{"pts": [{"x": 3, "y": 9}]}"#);

fn find(&self, keys: &[&str]) -> Option<&Value>

Traverses nested Maps to find the specified value by key.

Examples

let mut map = Map::new();
map.assign("user[name]", Value::String("Marie".into())).unwrap();

match map.find(&["user", "name"]) {
    Some(&Value::String(ref name)) => assert_eq!(name, "Marie"),
    _ => panic!("Unexpected parameter type!"),
}

assert!(map.find(&["user", "age"]).is_none());

fn to_strict_map<T: FromValue>(&self) -> Option<BTreeMap<String, T>>

Converts this map to a raw BTreeMap with values of all the same type.

let mut map = Map::new();
map.assign("x", Value::String("10.5".into())).unwrap();
map.assign("y", Value::I64(15)).unwrap();

let mut expected = BTreeMap::new();
expected.insert(String::from("x"), 10.5f32);
expected.insert(String::from("y"), 15.0f32);

assert_eq!(map.to_strict_map::<f32>(), Some(expected));

Methods from Deref<Target=BTreeMap<String, Value>>

fn clear(&mut self)

Clears the map, removing all values.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

fn get<Q>(&self, key: &Q) -> Option<&V> where K: Borrow<Q>, Q: Ord + ?Sized

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

fn contains_key<Q>(&self, key: &Q) -> bool where K: Borrow<Q>, Q: Ord + ?Sized

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Ord + ?Sized

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

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut(&1) {
    *x = "b";
}
assert_eq!(map[&1], "b");

fn insert(&mut self, key: K, value: V) -> Option<V>

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See the module-level documentation for more.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map[&37], "c");

fn remove<Q>(&mut self, key: &Q) -> Option<V> where K: Borrow<Q>, Q: Ord + ?Sized

Removes a key from the map, returning the value at the key if the key was previously in the map.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.remove(&1), Some("a"));
assert_eq!(map.remove(&1), None);

fn append(&mut self, other: &mut BTreeMap<K, V>)

Moves all elements from other into Self, leaving other empty.

Examples

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");

let mut b = BTreeMap::new();
b.insert(3, "d");
b.insert(4, "e");
b.insert(5, "f");

a.append(&mut b);

assert_eq!(a.len(), 5);
assert_eq!(b.len(), 0);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");
assert_eq!(a[&3], "d");
assert_eq!(a[&4], "e");
assert_eq!(a[&5], "f");

fn range<Min, Max>(&self, min: Bound<&Min>, max: Bound<&Max>) -> Range<K, V> where K: Borrow<Min> + Borrow<Max>, Max: Ord + ?Sized, Min: Ord + ?Sized

Unstable (btree_range)

: matches collection reform specification, waiting for dust to settle

Constructs a double-ended iterator over a sub-range of elements in the map, starting at min, and ending at max. If min is Unbounded, then it will be treated as "negative infinity", and if max is Unbounded, then it will be treated as "positive infinity". Thus range(Unbounded, Unbounded) will yield the whole collection.

Examples

Basic usage:

#![feature(btree_range, collections_bound)]

use std::collections::BTreeMap;
use std::collections::Bound::{Included, Unbounded};

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range(Included(&4), Included(&8)) {
    println!("{}: {}", key, value);
}
assert_eq!(Some((&5, &"b")), map.range(Included(&4), Unbounded).next());

fn range_mut<Min, Max>(&mut self, min: Bound<&Min>, max: Bound<&Max>) -> RangeMut<K, V> where K: Borrow<Min> + Borrow<Max>, Max: Ord + ?Sized, Min: Ord + ?Sized

Unstable (btree_range)

: matches collection reform specification, waiting for dust to settle

Constructs a mutable double-ended iterator over a sub-range of elements in the map, starting at min, and ending at max. If min is Unbounded, then it will be treated as "negative infinity", and if max is Unbounded, then it will be treated as "positive infinity". Thus range(Unbounded, Unbounded) will yield the whole collection.

Examples

Basic usage:

#![feature(btree_range, collections_bound)]

use std::collections::BTreeMap;
use std::collections::Bound::{Included, Excluded};

let mut map: BTreeMap<&str, i32> = ["Alice", "Bob", "Carol", "Cheryl"].iter()
                                                                      .map(|&s| (s, 0))
                                                                      .collect();
for (_, balance) in map.range_mut(Included("B"), Excluded("Cheryl")) {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{} => {}", name, balance);
}

fn entry(&mut self, key: K) -> Entry<K, V>

Gets the given key's corresponding entry in the map for in-place manipulation.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut count: BTreeMap<&str, usize> = BTreeMap::new();

// count the number of occurrences of letters in the vec
for x in vec!["a","b","a","c","a","b"] {
    *count.entry(x).or_insert(0) += 1;
}

assert_eq!(count["a"], 3);

fn split_off<Q>(&mut self, key: &Q) -> BTreeMap<K, V> where K: Borrow<Q>, Q: Ord + ?Sized

Splits the collection into two at the given key. Returns everything after the given key, including the key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");
a.insert(17, "d");
a.insert(41, "e");

let b = a.split_off(&3);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 3);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");

assert_eq!(b[&3], "c");
assert_eq!(b[&17], "d");
assert_eq!(b[&41], "e");

fn iter(&self) -> Iter<K, V>

Gets an iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{}: {}", key, value);
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));

fn iter_mut(&mut self) -> IterMut<K, V>

Gets a mutable iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

// add 10 to the value if the key isn't "a"
for (key, value) in map.iter_mut() {
    if key != &"a" {
        *value += 10;
    }
}

fn keys(&'a self) -> Keys<'a, K, V>

Gets an iterator over the keys of the map, in sorted order.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);

fn values(&'a self) -> Values<'a, K, V>

Gets an iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);

fn values_mut(&mut self) -> ValuesMut<K, V>

Gets a mutable iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, String::from("hello"));
a.insert(2, String::from("goodbye"));

for value in a.values_mut() {
    value.push_str("!");
}

let values: Vec<String> = a.values().cloned().collect();
assert_eq!(values, [String::from("hello!"),
                    String::from("goodbye!")]);

fn len(&self) -> usize

Returns the number of elements in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

Trait Implementations

impl PartialEq for Map

fn eq(&self, __arg_0: &Map) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Map) -> bool

This method tests for !=.

impl Clone for Map

fn clone(&self) -> Map

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for Map

type Target = BTreeMap<String, Value>

The resulting type after dereferencing

fn deref(&self) -> &BTreeMap<String, Value>

The method called to dereference a value

impl DerefMut for Map

fn deref_mut(&mut self) -> &mut BTreeMap<String, Value>

The method called to mutably dereference a value

impl Debug for Map

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.