[−][src]Struct pdf::primitive::Dictionary
Primitive Dictionary type.
Implementations
impl Dictionary
[src]
pub fn new() -> Dictionary
[src]
pub fn len(&self) -> usize
[src]
pub fn is_empty(&self) -> bool
[src]
pub fn get(&self, key: &str) -> Option<&Primitive>
[src]
pub fn insert(&mut self, key: String, val: Primitive) -> Option<Primitive>
[src]
pub fn iter(&self) -> Iter<'_, String, Primitive>
[src]
pub fn remove(&mut self, key: &str) -> Option<Primitive>
[src]
pub fn require(&mut self, typ: &'static str, key: &str) -> Result<Primitive>
[src]
like remove, but takes the name of the calling type and returns PdfError::MissingEntry
if the entry is not found
pub fn expect(
&self,
typ: &'static str,
key: &str,
value: &str,
required: bool
) -> Result<()>
[src]
&self,
typ: &'static str,
key: &str,
value: &str,
required: bool
) -> Result<()>
assert that the given key/value pair is in the dictionary (required=true
),
or the key is not present at all (required=false
)
Methods from Deref<Target = BTreeMap<String, Primitive>>
pub fn get<Q>(&self, key: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Ord + ?Sized,
1.0.0[src]
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);
pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)> where
K: Borrow<Q>,
Q: Ord + ?Sized,
1.40.0[src]
K: Borrow<Q>,
Q: Ord + ?Sized,
Returns the key-value pair corresponding to the supplied key.
The supplied 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
use std::collections::BTreeMap; let mut map = BTreeMap::new(); map.insert(1, "a"); assert_eq!(map.get_key_value(&1), Some((&1, &"a"))); assert_eq!(map.get_key_value(&2), None);
pub fn first_key_value(&self) -> Option<(&K, &V)>
[src]
map_first_last
)Returns the first key-value pair in the map. The key in this pair is the minimum key in the map.
Examples
Basic usage:
#![feature(map_first_last)] use std::collections::BTreeMap; let mut map = BTreeMap::new(); assert_eq!(map.first_key_value(), None); map.insert(1, "b"); map.insert(2, "a"); assert_eq!(map.first_key_value(), Some((&1, &"b")));
pub fn last_key_value(&self) -> Option<(&K, &V)>
[src]
map_first_last
)Returns the last key-value pair in the map. The key in this pair is the maximum key in the map.
Examples
Basic usage:
#![feature(map_first_last)] use std::collections::BTreeMap; let mut map = BTreeMap::new(); map.insert(1, "b"); map.insert(2, "a"); assert_eq!(map.last_key_value(), Some((&2, &"a")));
pub fn contains_key<Q>(&self, key: &Q) -> bool where
K: Borrow<Q>,
Q: Ord + ?Sized,
1.0.0[src]
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);
pub fn range<T, R>(&self, range: R) -> Range<'_, K, V> where
T: Ord + ?Sized,
R: RangeBounds<T>,
K: Borrow<T>,
1.17.0[src]
T: Ord + ?Sized,
R: RangeBounds<T>,
K: Borrow<T>,
Constructs a double-ended iterator over a sub-range of elements in the map.
The simplest way is to use the range syntax min..max
, thus range(min..max)
will
yield elements from min (inclusive) to max (exclusive).
The range may also be entered as (Bound<T>, Bound<T>)
, so for example
range((Excluded(4), Included(10)))
will yield a left-exclusive, right-inclusive
range from 4 to 10.
Panics
Panics if range start > end
.
Panics if range start == end
and both bounds are Excluded
.
Examples
Basic usage:
use std::collections::BTreeMap; use std::ops::Bound::Included; 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(4..).next());
pub fn iter(&self) -> Iter<'_, K, V>
1.0.0[src]
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"));
pub fn keys(&self) -> Keys<'_, K, V>
1.0.0[src]
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]);
pub fn values(&self) -> Values<'_, K, V>
1.0.0[src]
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"]);
pub const fn len(&self) -> usize
1.0.0[src]
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);
pub const fn is_empty(&self) -> bool
1.0.0[src]
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 Clone for Dictionary
[src]
fn clone(&self) -> Dictionary
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for Dictionary
[src]
impl Default for Dictionary
[src]
fn default() -> Dictionary
[src]
impl Deref for Dictionary
[src]
type Target = BTreeMap<String, Primitive>
The resulting type after dereferencing.
fn deref(&self) -> &BTreeMap<String, Primitive>
[src]
impl Display for Dictionary
[src]
impl From<Dictionary> for Primitive
[src]
fn from(x: Dictionary) -> Primitive
[src]
impl<'a> Index<&'a str> for Dictionary
[src]
type Output = Primitive
The returned type after indexing.
fn index(&self, idx: &'a str) -> &Primitive
[src]
impl<'a> IntoIterator for &'a Dictionary
[src]
type Item = (&'a String, &'a Primitive)
The type of the elements being iterated over.
type IntoIter = Iter<'a, String, Primitive>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl Object for Dictionary
[src]
Auto Trait Implementations
impl RefUnwindSafe for Dictionary
[src]
impl Send for Dictionary
[src]
impl Sync for Dictionary
[src]
impl Unpin for Dictionary
[src]
impl UnwindSafe for Dictionary
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> AnyObject for T where
T: Object + 'static,
[src]
T: Object + 'static,
pub fn serialize(&Self, &mut Vec<u8, Global>)
[src]
pub fn type_name(&Self) -> &'static str
[src]
pub fn type_id(&Self) -> TypeId
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,