# Trait ethcore_util::hashdb::HashDB [−] [src]

    pub trait HashDB: AsHashDB + Send + Sync {
        fn keys(&self) -> HashMap<H256, i32>;
        fn get(&self, key: &H256) -> Option<DBValue>;
        fn contains(&self, key: &H256) -> bool;
        fn insert(&mut self, value: &[u8]) -> H256;
        fn emplace(&mut self, key: H256, value: DBValue);
        fn remove(&mut self, key: &H256);
    }

Trait modelling datastore keyed by a 32-byte Keccak hash.

## Required Methods

### `fn keys(&self) -> HashMap<H256, i32>`

Get the keys in the database together with number of underlying references.

### `fn get(&self, key: &H256) -> Option<DBValue>`

Look up a given hash into the bytes that hash to it, returning None if the hash is not known.

# Examples

    extern crate ethcore_util;
    use ethcore_util::hashdb::*;
    use ethcore_util::memorydb::*;
    fn main() {
      let mut m = MemoryDB::new();
      let hello_bytes = "Hello world!".as_bytes();
      let hash = m.insert(hello_bytes);
      assert_eq!(m.get(&hash).unwrap(), hello_bytes);
    }

### `fn contains(&self, key: &H256) -> bool`

Check for the existance of a hash-key.

# Examples

    extern crate ethcore_util;
    use ethcore_util::hashdb::*;
    use ethcore_util::memorydb::*;
    use ethcore_util::sha3::*;
    fn main() {
      let mut m = MemoryDB::new();
      let hello_bytes = "Hello world!".as_bytes();
      assert!(!m.contains(&hello_bytes.sha3()));
      let key = m.insert(hello_bytes);
      assert!(m.contains(&key));
      m.remove(&key);
      assert!(!m.contains(&key));
    }

### `fn insert(&mut self, value: &[u8]) -> H256`

Insert a datum item into the DB and return the datum's hash for a later lookup. Insertions are counted and the equivalent number of `remove()`s must be performed before the data is considered dead.

# Examples

    extern crate ethcore_util;
    use ethcore_util::hashdb::*;
    use ethcore_util::memorydb::*;
    use ethcore_util::hash::*;
    fn main() {
      let mut m = MemoryDB::new();
      let key = m.insert("Hello world!".as_bytes());
      assert!(m.contains(&key));
    }

### `fn emplace(&mut self, key: H256, value: DBValue)`

Like `insert()` , except you provide the key and the data is all moved.

### `fn remove(&mut self, key: &H256)`

Remove a datum previously inserted. Insertions can be "owed" such that the same number of `insert()`s may happen without the data being eventually being inserted into the DB.

# Examples

    extern crate ethcore_util;
    use ethcore_util::hashdb::*;
    use ethcore_util::memorydb::*;
    use ethcore_util::sha3::*;
    fn main() {
      let mut m = MemoryDB::new();
      let d = "Hello world!".as_bytes();
      let key = &d.sha3();
      m.remove(key);    // OK - we now owe an insertion.
      assert!(!m.contains(key));
      m.insert(d);  // OK - now it's "empty" again.
      assert!(!m.contains(key));
      m.insert(d);  // OK - now we've
      assert_eq!(m.get(key).unwrap(), d);
    }

## Implementors

- `impl HashDB for MemoryDB`
- `impl HashDB for OverlayDB`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)