Struct opendp::domains::MapDomain

pub struct MapDomain<DK: Domain, DV: Domain>
where
    DK::Carrier: Eq + Hash,
{
    pub key_domain: DK,
    pub value_domain: DV,
}

A Domain that contains maps of (homogeneous) values.

Proof Definition

MapDomain(key_domain, value_domain, DK, DV) consists of all hashmaps where keys are elements of key_domain (of type DK) and values are elements of value_domain (of type DV).

The elements in the DK domain are hashable and have a strict equality operation.

Example

use opendp::domains::{MapDomain, AtomDomain};
// Rust infers the type from the context, at compile-time.
// Members of this domain are of type `HashMap<&str, i32>`.
let domain = MapDomain::new(AtomDomain::default(), AtomDomain::default());

use opendp::core::Domain;
use std::collections::HashMap;

// create a hashmap we can test with
let hashmap = HashMap::from_iter([("a", 23), ("b", 12)]);
assert!(domain.member(&hashmap)?);

// Can build up more complicated domains as needed:
let value_domain = AtomDomain::new_closed((0., 1.))?;
let domain = MapDomain::new(AtomDomain::default(), value_domain);

// The following is not a member of the hashmap domain, because a value is out-of-range:
let hashmap = HashMap::from_iter([("a", 0.), ("b", 2.)]);
assert!(!domain.member(&hashmap)?);

Fields

key_domain: DK

value_domain: DV

Implementations

impl<DK: Domain, DV: Domain> MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

pub fn new(key_domain: DK, element_domain: DV) -> Self

Trait Implementations

impl<DK: Clone + Domain, DV: Clone + Domain> Clone for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

fn clone(&self) -> MapDomain<DK, DV>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DK: Debug + Domain, DV: Debug + Domain> Debug for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

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

Formats the value using the given formatter.

impl<DK: Default + Domain, DV: Default + Domain> Default for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

fn default() -> MapDomain<DK, DV>

Returns the “default value” for a type.

impl<DK: Domain, DV: Domain> Domain for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

type Carrier = HashMap<<DK as Domain>::Carrier, <DV as Domain>::Carrier>

The underlying type that the Domain specializes. This is the type of a member of a domain, where a domain is any data type that implements this trait.

fn member(&self, val: &Self::Carrier) -> Fallible<bool>

Predicate to test an element for membership in the domain. Not all possible values of ::Carrier are a member of the domain.

impl<DK: PartialEq + Domain, DV: PartialEq + Domain> PartialEq for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,

fn eq(&self, other: &MapDomain<DK, DV>) -> bool

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

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

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

impl<DK: Domain, DV: Domain> StructuralPartialEq for MapDomain<DK, DV>

where DK::Carrier: Eq + Hash,