Struct Dictionary 

pub struct Dictionary { /* private fields */ }

Primitive Dictionary type.

Implementations

impl Dictionary

pub fn new() -> Dictionary

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get(&self, key: &str) -> Option<&Primitive>

pub fn insert( &mut self, key: impl Into<Name>, val: impl Into<Primitive>, ) -> Option<Primitive>

pub fn iter(&self) -> impl Iterator<Item = (&Name, &Primitive)>

pub fn remove(&mut self, key: &str) -> Option<Primitive>

pub fn require(&mut self, typ: &'static str, key: &str) -> Result<Primitive>

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<()>

assert that the given key/value pair is in the dictionary (required=true), or the key is not present at all (required=false)

pub fn append(&mut self, other: Dictionary)

Methods from Deref<Target = IndexMap<Name, Primitive>>

pub fn capacity(&self) -> usize

Return the number of elements the map can hold without reallocating.

This number is a lower bound; the map might be able to hold more, but is guaranteed to be able to hold at least this many.

Computes in O(1) time.

pub fn hasher(&self) -> &S

Return a reference to the map’s BuildHasher.

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

Computes in O(1) time.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Computes in O(1) time.

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

Return an iterator over the key-value pairs of the map, in their order

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

Return an iterator over the keys of the map, in their order

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

Return an iterator over the values of the map, in their order

pub fn contains_key<Q>(&self, key: &Q) -> bool

where Q: Hash + Equivalent<K> + ?Sized,

Return true if an equivalent to key exists in the map.

Computes in O(1) time (average).

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where Q: Hash + Equivalent<K> + ?Sized,

Return a reference to the stored value for key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return references to the stored key-value pair for the lookup key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_full<Q>(&self, key: &Q) -> Option<(usize, &K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Return the index with references to the stored key-value pair for the lookup key, if it is present, else None.

Computes in O(1) time (average).

pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>

where Q: Hash + Equivalent<K> + ?Sized,

Return the item index for key, if it is present, else None.

Computes in O(1) time (average).

pub fn binary_search_keys(&self, x: &K) -> Result<usize, usize>

where K: Ord,

Search over a sorted map for a key.

Returns the position where that key is present, or the position where it can be inserted to maintain the sort. See slice::binary_search for more details.

Computes in O(log(n)) time, which is notably less scalable than looking the key up using get_index_of, but this can also position missing keys.

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> Ordering,

Search over a sorted map with a comparator function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by for more details.

Computes in O(log(n)) time.

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>

where F: FnMut(&'a K, &'a V) -> B, B: Ord,

Search over a sorted map with an extraction function.

Returns the position where that value is present, or the position where it can be inserted to maintain the sort. See slice::binary_search_by_key for more details.

Computes in O(log(n)) time.

pub fn is_sorted(&self) -> bool

where K: PartialOrd,

Checks if the keys of this map are sorted.

pub fn is_sorted_by<'a, F>(&'a self, cmp: F) -> bool

where F: FnMut(&'a K, &'a V, &'a K, &'a V) -> bool,

Checks if this map is sorted using the given comparator function.

pub fn is_sorted_by_key<'a, F, T>(&'a self, sort_key: F) -> bool

where F: FnMut(&'a K, &'a V) -> T, T: PartialOrd,

Checks if this map is sorted using the given sort-key function.

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&K, &V) -> bool,

Returns the index of the partition point of a sorted map according to the given predicate (the index of the first element of the second partition).

See slice::partition_point for more details.

Computes in O(log(n)) time.

pub fn as_slice(&self) -> &Slice<K, V>

Returns a slice of all the key-value pairs in the map.

Computes in O(1) time.

pub fn get_index(&self, index: usize) -> Option<(&K, &V)>

Get a key-value pair by index

Valid indices are 0 <= index < self.len().

Computes in O(1) time.

pub fn get_range<R>(&self, range: R) -> Option<&Slice<K, V>>

where R: RangeBounds<usize>,

Returns a slice of key-value pairs in the given range of indices.

Valid indices are 0 <= index < self.len().

Computes in O(1) time.

pub fn first(&self) -> Option<(&K, &V)>

Get the first key-value pair

Computes in O(1) time.

pub fn last(&self) -> Option<(&K, &V)>

Get the last key-value pair

Computes in O(1) time.

Trait Implementations

impl Clone for Dictionary

fn clone(&self) -> Dictionary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataSize for Dictionary

const IS_DYNAMIC: bool = true

If true, the type has a heap size that can vary at runtime, depending on the actual value.

const STATIC_HEAP_SIZE: usize = 72usize

The amount of space a value of the type always occupies. If IS_DYNAMIC is false, this is the total amount of heap memory occupied by the value. Otherwise this is a lower bound.

fn estimate_heap_size(&self) -> usize

Estimates the size of heap memory taken up by this value.

impl Debug for Dictionary

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

Formats the value using the given formatter.

impl DeepClone for Dictionary

fn deep_clone(&self, cloner: &mut impl Cloner) -> Result<Self>

impl Default for Dictionary

fn default() -> Dictionary

Returns the “default value” for a type.

impl Deref for Dictionary

type Target = IndexMap<Name, Primitive>

The resulting type after dereferencing.

fn deref(&self) -> &IndexMap<Name, Primitive>

Dereferences the value.

impl Display for Dictionary

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

Formats the value using the given formatter.

impl From<Dictionary> for Primitive

fn from(x: Dictionary) -> Primitive

Converts to this type from the input type.

impl<'a> Index<&'a str> for Dictionary

type Output = Primitive

The returned type after indexing.

fn index(&self, idx: &'a str) -> &Primitive

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Dictionary

type Item = (&'a Name, &'a Primitive)

The type of the elements being iterated over.

type IntoIter = Iter<'a, Name, Primitive>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Dictionary

type Item = (Name, Primitive)

The type of the elements being iterated over.

type IntoIter = IntoIter<Name, Primitive>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Object for Dictionary

fn from_primitive(p: Primitive, r: &impl Resolve) -> Result<Self>

Convert primitive to Self

impl ObjectWrite for Dictionary

fn to_primitive(&self, _update: &mut impl Updater) -> Result<Primitive>

impl PartialEq for Dictionary

fn eq(&self, other: &Dictionary) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Dictionary