Struct RequirementsMap

Source

pub struct RequirementsMap(pub HashMap<String, Requirement>);

Expand description

Map of requirements to be submitted. Each key is the field name (e.g., “ssnLast4”), with values to describe its state. Requirements are only shown for requested capabilities. When a requirement is verified, it disappears from this map.

For the `tos` key, each entry in `tosVersions[]` has its own optional
deadline. The requirement-level `deadline` is an aggregate of those rows:
the earliest set deadline among unaccepted versions, not a separate clock.
A version with no deadline requires immediate acceptance but keeps the
aggregate status `due`. A future deadline is also `due` and represents
non-blocking grace. The aggregate status is `past_due` only when at least
one unaccepted version has a deadline set in the past. Do not infer status
or blocking behavior from omission of the aggregate deadline.

JSON schema

{
 "description": "Map of requirements to be submitted. Each key is the field name\n(e.g., \"ssnLast4\"), with values to describe its state. Requirements\nare only shown for requested capabilities. When a requirement is\nverified, it disappears from this map.\n\nFor the `tos` key, each entry in `tosVersions[]` has its own optional\ndeadline. The requirement-level `deadline` is an aggregate of those rows:\nthe earliest set deadline among unaccepted versions, not a separate clock.\nA version with no deadline requires immediate acceptance but keeps the\naggregate status `due`. A future deadline is also `due` and represents\nnon-blocking grace. The aggregate status is `past_due` only when at least\none unaccepted version has a deadline set in the past. Do not infer status\nor blocking behavior from omission of the aggregate deadline.\n",
 "examples": [
   {
     "citizenship": {
       "status": "due"
     },
     "firstName": {
       "impact": [
         "custodyCrypto",
         "transferCrypto"
       ],
       "status": "due"
     },
     "fullSsn": {
       "impact": [
         "custodyCrypto"
       ],
       "status": "rejected"
     },
     "sourceOfFunds": {
       "status": "due"
     },
     "ssnLast4": {
       "impact": [
         "custodyCrypto"
       ],
       "status": "pending"
     },
     "taxAttestation": {
       "impact": [
         "transferFiat"
       ],
       "status": "due",
       "taxForms": [
         "us_w9"
       ]
     },
     "tos": {
       "impact": [
         "transferFiat"
       ],
       "status": "due",
       "tosVersions": [
         {
           "languages": [
             "en"
           ],
           "url": "https://www.coinbase.com/legal/user-agreements-third-party-provider",
           "versionId": "us_individual_2026-05-29"
         }
       ]
     }
   }
 ],
 "type": "object",
 "additionalProperties": {
   "$ref": "#/components/schemas/Requirement"
 }
}

Tuple Fields§

§0: HashMap<String, Requirement>

Methods from Deref<Target = HashMap<String, Requirement>>§

1.0.0 · Source

pub fn capacity(&self) -> usize

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<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);

1.0.0 · Source

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

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

§Examples

use std::collections::HashMap;

let map: HashMap<&str, i32> = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut values: Vec<_> = map.keys().copied().collect();
values.sort();

assert_eq!(values, vec!["a", "b", "c"]);

§Performance

In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

1.0.0 · Source

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

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

§Examples

use std::collections::HashMap;

let map: HashMap<&str, i32> = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut values: Vec<_> = map.values().copied().collect();
values.sort();

assert_eq!(values, vec![1, 2, 3]);

§Performance

In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

1.0.0 · Source

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

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 map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

let mut count = 0;

for (_key, _val) in map.iter() {
    count += 1;
}

assert_eq!(count, 3);

§Performance

In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

1.0.0 · Source

pub fn len(&self) -> usize

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

1.0.0 · Source

pub fn is_empty(&self) -> bool

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

1.9.0 · Source

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

§Examples

use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();

1.0.0 · Source

pub fn get<Q>(&self, k: &Q) -> Option<&V>
where 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);

1.40.0 · Source

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the key-value pair corresponding to the supplied key. This is potentially useful:

for key types where non-identical keys can be considered equal;
for getting the &K stored key value from a borrowed &Q lookup key; or
for getting a reference to a key with the same lifetime as the collection.

The supplied 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;
use std::hash::{Hash, Hasher};

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and hashing operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl Hash for S {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = HashMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), None);

1.0.0 · Source

pub fn contains_key<Q>(&self, k: &Q) -> bool
where 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);