Struct diesel_pg_hstore::Hstore
[−]
[src]
pub struct Hstore(_);
The Hstore wrapper type.
Methods
impl Hstore
[src]
fn new() -> Hstore
[src]
Create a new Hstore object
fn from_hashmap(hm: HashMap<String, String>) -> Hstore
[src]
Create a new Hstore from an existing hashmap
use diesel_pg_hstore::Hstore; use std::collections::HashMap; let mut settings = HashMap::new(); settings.insert("Hello".into(), "World".into()); let settings_hstore = Hstore::from_hashmap(settings);
fn with_capacity(capacity: usize) -> Hstore
[src]
Please see HashMap.with_capacity
fn capacity(&self) -> usize
[src]
Please see HashMap.capacity
fn reserve(&mut self, additional: usize)
[src]
Please see HashMap.reserve
fn shrink_to_fit(&mut self)
[src]
Please see HashMap.shrink_to_fit
fn keys(&self) -> Keys<String, String>
[src]
Please see HashMap.keys
fn values(&self) -> Values<String, String>
[src]
Please see HashMap.values
fn values_mut(&mut self) -> ValuesMut<String, String>
[src]
Please see HashMap.values_mut
fn iter(&self) -> Iter<String, String>
[src]
Please see HashMap.iter
fn iter_mut(&mut self) -> IterMut<String, String>
[src]
Please see HashMap.iter_mut
fn entry(&mut self, key: String) -> Entry<String, String>
[src]
Please see HashMap.entry
fn len(&self) -> usize
[src]
Please see HashMap.len
fn is_empty(&self) -> bool
[src]
Please see HashMap.is_empty
fn drain(&mut self) -> Drain<String, String>
[src]
Please see HashMap.drain
fn clear(&mut self)
[src]
Please see HashMap.clear
fn get(&self, k: &str) -> Option<&String>
[src]
Please see HashMap.get
fn get_mut(&mut self, k: &str) -> Option<&mut String>
[src]
Please see HashMap.get_mut
fn contains_key(&self, k: &str) -> bool
[src]
Please see HashMap.contains_key
fn insert(&mut self, k: String, v: String) -> Option<String>
[src]
Please see HashMap.insert
fn remove(&mut self, k: &str) -> Option<String>
[src]
Please see HashMap.remove
fn retain<F>(&mut self, f: F) where
F: FnMut(&String, &mut String) -> bool,
[src]
F: FnMut(&String, &mut String) -> bool,
Please see HashMap.retain
Methods from Deref<Target = HashMap<String, String>>
fn hasher(&self) -> &S
1.9.0[src]
Returns a reference to the map's BuildHasher
.
fn capacity(&self) -> usize
1.0.0[src]
Returns the number of elements the map can hold without reallocating.
This number is a lower bound; the HashMap<K, V>
might be able to hold
more, but is guaranteed to be able to hold at least this many.
Examples
use std::collections::HashMap; let map: HashMap<isize, isize> = HashMap::with_capacity(100); assert!(map.capacity() >= 100);
fn reserve(&mut self, additional: usize)
1.0.0[src]
Reserves capacity for at least additional
more elements to be inserted
in the HashMap
. The collection may reserve more space to avoid
frequent reallocations.
Panics
Panics if the new allocation size overflows usize
.
Examples
use std::collections::HashMap; let mut map: HashMap<&str, isize> = HashMap::new(); map.reserve(10);
fn shrink_to_fit(&mut self)
1.0.0[src]
Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.
Examples
use std::collections::HashMap; let mut map: HashMap<isize, isize> = HashMap::with_capacity(100); map.insert(1, 2); map.insert(3, 4); assert!(map.capacity() >= 100); map.shrink_to_fit(); assert!(map.capacity() >= 2);
fn keys(&self) -> Keys<K, V>
1.0.0[src]
An iterator visiting all keys in arbitrary order.
The iterator element type is &'a K
.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); for key in map.keys() { println!("{}", key); }
fn values(&self) -> Values<K, V>
1.0.0[src]
An iterator visiting all values in arbitrary order.
The iterator element type is &'a V
.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); for val in map.values() { println!("{}", val); }
fn values_mut(&mut self) -> ValuesMut<K, V>
1.10.0[src]
An iterator visiting all values mutably in arbitrary order.
The iterator element type is &'a mut V
.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); for val in map.values_mut() { *val = *val + 10; } for val in map.values() { println!("{}", val); }
fn iter(&self) -> Iter<K, V>
1.0.0[src]
An iterator visiting all key-value pairs in arbitrary order.
The iterator element type is (&'a K, &'a V)
.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); for (key, val) in map.iter() { println!("key: {} val: {}", key, val); }
fn iter_mut(&mut self) -> IterMut<K, V>
1.0.0[src]
An iterator visiting all key-value pairs in arbitrary order,
with mutable references to the values.
The iterator element type is (&'a K, &'a mut V)
.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); // Update all values for (_, val) in map.iter_mut() { *val *= 2; } for (key, val) in &map { println!("key: {} val: {}", key, val); }
fn entry(&mut self, key: K) -> Entry<K, V>
1.0.0[src]
Gets the given key's corresponding entry in the map for in-place manipulation.
Examples
use std::collections::HashMap; let mut letters = HashMap::new(); for ch in "a short treatise on fungi".chars() { let counter = letters.entry(ch).or_insert(0); *counter += 1; } assert_eq!(letters[&'s'], 2); assert_eq!(letters[&'t'], 3); assert_eq!(letters[&'u'], 1); assert_eq!(letters.get(&'y'), None);
fn len(&self) -> usize
1.0.0[src]
Returns the number of elements in the map.
Examples
use std::collections::HashMap; let mut a = HashMap::new(); assert_eq!(a.len(), 0); a.insert(1, "a"); assert_eq!(a.len(), 1);
fn is_empty(&self) -> bool
1.0.0[src]
Returns true if the map contains no elements.
Examples
use std::collections::HashMap; let mut a = HashMap::new(); assert!(a.is_empty()); a.insert(1, "a"); assert!(!a.is_empty());
fn drain(&mut self) -> Drain<K, V>
1.6.0[src]
Clears the map, returning all key-value pairs as an iterator. Keeps the allocated memory for reuse.
Examples
use std::collections::HashMap; let mut a = HashMap::new(); a.insert(1, "a"); a.insert(2, "b"); for (k, v) in a.drain().take(1) { assert!(k == 1 || k == 2); assert!(v == "a" || v == "b"); } assert!(a.is_empty());
fn clear(&mut self)
1.0.0[src]
Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.
Examples
use std::collections::HashMap; let mut a = HashMap::new(); a.insert(1, "a"); a.clear(); assert!(a.is_empty());
fn get<Q>(&self, k: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
1.0.0[src]
K: Borrow<Q>,
Q: Hash + Eq + ?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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); assert_eq!(map.get(&1), Some(&"a")); assert_eq!(map.get(&2), None);
fn contains_key<Q>(&self, k: &Q) -> bool where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
1.0.0[src]
K: Borrow<Q>,
Q: Hash + Eq + ?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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap; let mut map = HashMap::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, k: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
1.0.0[src]
K: Borrow<Q>,
Q: Hash + Eq + ?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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); if let Some(x) = map.get_mut(&1) { *x = "b"; } assert_eq!(map[&1], "b");
fn insert(&mut self, k: K, v: V) -> Option<V>
1.0.0[src]
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
use std::collections::HashMap; let mut map = HashMap::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, k: &Q) -> Option<V> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
1.0.0[src]
K: Borrow<Q>,
Q: Hash + Eq + ?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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); assert_eq!(map.remove(&1), Some("a")); assert_eq!(map.remove(&1), None);
fn retain<F>(&mut self, f: F) where
F: FnMut(&K, &mut V) -> bool,
1.18.0[src]
F: FnMut(&K, &mut V) -> bool,
Retains only the elements specified by the predicate.
In other words, remove all pairs (k, v)
such that f(&k,&mut v)
returns false
.
Examples
use std::collections::HashMap; let mut map: HashMap<isize, isize> = (0..8).map(|x|(x, x*10)).collect(); map.retain(|&k, _| k % 2 == 0); assert_eq!(map.len(), 4);
Trait Implementations
impl NotNull for Hstore
[src]
impl SingleValue for Hstore
[src]
impl Queryable<Hstore, Pg> for Hstore
[src]
impl<'a> AsExpression<Hstore> for &'a Hstore
[src]
type Expression = Bound<Hstore, &'a Hstore>
fn as_expression(self) -> Self::Expression
[src]
impl FromSql<Hstore, Pg> for Hstore
[src]
impl FromSqlRow<Hstore, Pg> for Hstore
[src]
fn build_from_row<T: Row<Pg>>(
row: &mut T
) -> Result<Self, Box<StdError + Send + Sync>>
[src]
row: &mut T
) -> Result<Self, Box<StdError + Send + Sync>>
const FIELDS_NEEDED: usize
The number of fields that this type will consume. Must be equal to the number of times you would call row.take()
in build_from_row
Read more
impl ToSql<Hstore, Pg> for Hstore
[src]
fn to_sql<W>(
&self,
out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<StdError + Send + Sync>> where
W: Write,
[src]
&self,
out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<StdError + Send + Sync>> where
W: Write,
impl Debug for Hstore
[src]
impl Clone for Hstore
[src]
fn clone(&self) -> Hstore
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Default for Hstore
[src]
impl PartialEq for Hstore
[src]
fn eq(&self, __arg_0: &Hstore) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Hstore) -> bool
[src]
This method tests for !=
.
impl Eq for Hstore
[src]
impl Deref for Hstore
[src]
You can deref the Hstore into it's backing HashMap
use diesel_pg_hstore::Hstore; use std::collections::HashMap; let mut settings = Hstore::new(); settings.insert("Hello".into(), "World".into()); let hashmap: &HashMap<String, String> = &*settings;
type Target = HashMap<String, String>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
Dereferences the value.
impl DerefMut for Hstore
[src]
You can mutably deref the Hstore into it's backing HashMap
use diesel_pg_hstore::Hstore; use std::collections::HashMap; let mut settings = Hstore::new(); settings.insert("Hello".into(), "World".into()); let mut hashmap: &mut HashMap<String, String> = &mut *settings;
impl IntoIterator for Hstore
[src]
type Item = (String, String)
The type of the elements being iterated over.
type IntoIter = IntoIter<String, String>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
Creates an iterator from a value. Read more
impl<'a> IntoIterator for &'a Hstore
[src]
type Item = (&'a String, &'a String)
The type of the elements being iterated over.
type IntoIter = Iter<'a, String, String>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
Creates an iterator from a value. Read more
impl<'a> IntoIterator for &'a mut Hstore
[src]
type Item = (&'a String, &'a mut String)
The type of the elements being iterated over.
type IntoIter = IterMut<'a, String, String>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
Creates an iterator from a value. Read more
impl FromIterator<(String, String)> for Hstore
[src]
fn from_iter<T>(iter: T) -> Hstore where
T: IntoIterator<Item = (String, String)>,
[src]
T: IntoIterator<Item = (String, String)>,
Creates a value from an iterator. Read more
impl<'a> Index<&'a str> for Hstore
[src]
type Output = String
The returned type after indexing.
fn index(&self, index: &'a str) -> &Self::Output
[src]
Performs the indexing (container[index]
) operation.