SYMBOL INDEX (546 symbols across 30 files)

FILE: benches/merk.rs
  function get_1m_rocksdb (line 14) | fn get_1m_rocksdb(b: &mut Bencher) {
  function insert_1m_2k_seq_rocksdb_noprune (line 42) | fn insert_1m_2k_seq_rocksdb_noprune(b: &mut Bencher) {
  function insert_1m_2k_rand_rocksdb_noprune (line 63) | fn insert_1m_2k_rand_rocksdb_noprune(b: &mut Bencher) {
  function update_1m_2k_seq_rocksdb_noprune (line 84) | fn update_1m_2k_seq_rocksdb_noprune(b: &mut Bencher) {
  function update_1m_2k_rand_rocksdb_noprune (line 105) | fn update_1m_2k_rand_rocksdb_noprune(b: &mut Bencher) {
  function delete_1m_2k_rand_rocksdb_noprune (line 126) | fn delete_1m_2k_rand_rocksdb_noprune(b: &mut Bencher) {
  function prove_1m_1_rand_rocksdb_noprune (line 151) | fn prove_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {
  function build_trunk_chunk_1m_1_rand_rocksdb_noprune (line 180) | fn build_trunk_chunk_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {
  function chunkproducer_rand_1m_1_rand_rocksdb_noprune (line 208) | fn chunkproducer_rand_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {
  function chunk_iter_1m_1_rand_rocksdb_noprune (line 241) | fn chunk_iter_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {
  function restore_1m_1_rand_rocksdb_noprune (line 275) | fn restore_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {
  function checkpoint_create_destroy_1m_1_rand_rocksdb_noprune (line 325) | fn checkpoint_create_destroy_1m_1_rand_rocksdb_noprune(b: &mut Bencher) {

FILE: benches/ops.rs
  function insert_1m_10k_seq_memonly (line 10) | fn insert_1m_10k_seq_memonly(b: &mut Bencher) {
  function insert_1m_10k_rand_memonly (line 25) | fn insert_1m_10k_rand_memonly(b: &mut Bencher) {
  function update_1m_10k_seq_memonly (line 40) | fn update_1m_10k_seq_memonly(b: &mut Bencher) {
  function update_1m_10k_rand_memonly (line 55) | fn update_1m_10k_rand_memonly(b: &mut Bencher) {

FILE: src/error.rs
  type Error (line 4) | pub enum Error {
  type Result (line 52) | pub type Result<T> = std::result::Result<T, Error>;

FILE: src/merk/chunks.rs
  type ChunkProducer (line 16) | pub struct ChunkProducer<'a> {
  function new (line 26) | pub fn new(merk: &'a Merk) -> Result<Self> {
  function chunk (line 58) | pub fn chunk(&mut self, index: usize) -> Result<Vec<u8>> {
  function len (line 78) | pub fn len(&self) -> usize {
  function next_chunk (line 90) | fn next_chunk(&mut self) -> Result<Vec<u8>> {
  type IntoIter (line 114) | type IntoIter = ChunkIter<'a>;
  type Item (line 115) | type Item = <ChunkIter<'a> as Iterator>::Item;
  method into_iter (line 117) | fn into_iter(self) -> Self::IntoIter {
  type ChunkIter (line 125) | pub struct ChunkIter<'a>(ChunkProducer<'a>);
  type Item (line 128) | type Item = Result<Vec<u8>>;
  method size_hint (line 130) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next (line 134) | fn next(&mut self) -> Option<Self::Item> {
  method chunks (line 146) | pub fn chunks(&self) -> Result<ChunkProducer> {
  function len_small (line 163) | fn len_small() {
  function len_big (line 174) | fn len_big() {
  function generate_and_verify_chunks (line 185) | fn generate_and_verify_chunks() -> Result<()> {
  function chunks_from_reopen (line 208) | fn chunks_from_reopen() {
  function chunks_from_checkpoint (line 237) | fn chunks_from_checkpoint() {
  function random_access_chunks (line 259) | fn random_access_chunks() {
  function test_chunk_empty (line 280) | fn test_chunk_empty() {
  function test_chunk_index_oob (line 293) | fn test_chunk_index_oob() {
  function test_chunk_index_gt_1_access (line 303) | fn test_chunk_index_gt_1_access() {
  function test_next_chunk_index_oob (line 385) | fn test_next_chunk_index_oob() {

FILE: src/merk/mod.rs
  constant ROOT_KEY_KEY (line 19) | const ROOT_KEY_KEY: &[u8] = b"root";
  constant FORMAT_VERSION_KEY (line 20) | const FORMAT_VERSION_KEY: &[u8] = b"format";
  constant AUX_CF_NAME (line 21) | const AUX_CF_NAME: &str = "aux";
  constant INTERNAL_CF_NAME (line 22) | const INTERNAL_CF_NAME: &str = "internal";
  constant FORMAT_VERSION (line 24) | const FORMAT_VERSION: u64 = 1;
  function column_families (line 26) | fn column_families() -> Vec<ColumnFamilyDescriptor> {
  type Merk (line 35) | pub struct Merk {
    method open (line 46) | pub fn open<P: AsRef<Path>>(path: P) -> Result<Merk> {
    method open_readonly (line 51) | pub fn open_readonly<P: AsRef<Path>>(path: P) -> Result<Merk> {
    method open_opt (line 80) | pub fn open_opt<P>(path: P, db_opts: rocksdb::Options) -> Result<Merk>
    method open_and_get_aux (line 112) | pub fn open_and_get_aux<P>(path: P, key: &[u8]) -> Result<Option<Vec<u...
    method default_db_opts (line 123) | pub fn default_db_opts() -> rocksdb::Options {
    method get_aux (line 144) | pub fn get_aux(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
    method get (line 154) | pub fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
    method root_hash (line 165) | pub fn root_hash(&self) -> Hash {
    method apply (line 189) | pub fn apply(&mut self, batch: &Batch, aux: &Batch) -> Result<()> {
    method apply_unchecked (line 231) | pub unsafe fn apply_unchecked(&mut self, batch: &Batch, aux: &Batch) -...
    method destroy (line 244) | pub fn destroy(self) -> Result<()> {
    method repair (line 254) | pub fn repair(self) -> Result<Self> {
    method migrate_from_v0 (line 307) | pub fn migrate_from_v0<P: AsRef<Path>>(path: P) -> Result<()> {
    method prove (line 342) | pub fn prove<Q, I>(&self, query: I) -> Result<Vec<u8>>
    method flush (line 350) | pub fn flush(&self) -> Result<()> {
    method commit (line 354) | pub fn commit(&mut self, deleted_keys: LinkedList<Vec<u8>>, aux: &Batc...
    method walk (line 412) | pub fn walk<T>(&self, f: impl FnOnce(Option<RefWalker<MerkSource>>) ->...
    method raw_iter (line 420) | pub fn raw_iter(&self) -> rocksdb::DBRawIterator {
    method checkpoint (line 424) | pub fn checkpoint<P: AsRef<Path>>(&self, path: P) -> Result<Merk> {
    method snapshot (line 429) | pub fn snapshot(&self) -> Result<Snapshot> {
    method db (line 433) | pub fn db(&self) -> &DB {
    method source (line 437) | fn source(&self) -> MerkSource {
    method use_tree (line 441) | fn use_tree<T>(&self, f: impl FnOnce(Option<&Tree>) -> T) -> T {
    method use_tree_mut (line 446) | fn use_tree_mut<T>(&self, f: impl FnOnce(Option<&mut Tree>) -> T) -> T {
    method write (line 454) | pub(crate) fn write(&mut self, batch: WriteBatch) -> Result<()> {
    method set_root_key (line 462) | pub(crate) fn set_root_key(&mut self, key: Vec<u8>) -> Result<()> {
    method fetch_node (line 469) | pub(crate) fn fetch_node(&self, key: &[u8]) -> Result<Option<Tree>> {
    method load_root (line 473) | pub(crate) fn load_root(&mut self) -> Result<()> {
  type UseTreeMutResult (line 41) | pub type UseTreeMutResult = Result<Vec<(Vec<u8>, Option<Vec<u8>>)>>;
  type MerkSource (line 481) | pub struct MerkSource<'a> {
  method fetch_by_key (line 486) | fn fetch_by_key(&self, key: &[u8]) -> Result<Option<Tree>> {
  type MerkCommitter (line 494) | struct MerkCommitter {
    method new (line 501) | fn new(height: u8, levels: u8) -> Self {
  method write (line 511) | fn write(&mut self, tree: &Tree) -> Result<()> {
  method prune (line 518) | fn prune(&self, tree: &Tree) -> (bool, bool) {
  function get (line 525) | pub fn get<F: Fetch>(tree: &Tree, source: F, key: &[u8]) -> Result<Optio...
  function root_hash (line 533) | fn root_hash(maybe_tree: Option<&Tree>) -> Hash {
  function prove (line 537) | fn prove<Q, I, F>(maybe_tree: Option<&mut Tree>, source: F, query: I) ->...
  function has_root (line 556) | fn has_root(db: &DB) -> Result<bool> {
  function load_root (line 561) | fn load_root(db: &DB) -> Result<Option<Tree>> {
  function load_format_version (line 568) | fn load_format_version(db: &DB) -> Result<u64> {
  function assert_invariants (line 589) | fn assert_invariants(merk: &TempMerk) {
  function simple_insert_apply (line 597) | fn simple_insert_apply() {
  function insert_uncached (line 617) | fn insert_uncached() {
  function insert_rand (line 633) | fn insert_rand() {
  function actual_deletes (line 648) | fn actual_deletes() {
  function aux_data (line 663) | fn aux_data() {
  function simulated_crash (line 673) | fn simulated_crash() {
  function get_not_found (line 698) | fn get_not_found() {
  function reopen (line 724) | fn reopen() {
  function reopen_iter (line 766) | fn reopen_iter() {
  function checkpoint (line 799) | fn checkpoint() {
  function checkpoint_iterator (line 838) | fn checkpoint_iterator() {
  function repair (line 871) | fn repair() {

FILE: src/merk/restore.rs
  type Restorer (line 22) | pub struct Restorer {
    method new (line 42) | pub fn new<P: AsRef<Path>>(
    method process_chunk (line 67) | pub fn process_chunk(&mut self, chunk_bytes: &[u8]) -> Result<usize> {
    method finalize (line 80) | pub fn finalize(mut self) -> Result<Merk> {
    method remaining_chunks (line 100) | pub fn remaining_chunks(&self) -> Option<usize> {
    method write_chunk (line 106) | fn write_chunk(&mut self, tree: ProofTree) -> Result<()> {
    method process_trunk (line 134) | fn process_trunk(&mut self, ops: Decoder) -> Result<usize> {
    method process_leaf (line 193) | fn process_leaf(&mut self, ops: Decoder) -> Result<usize> {
    method rewrite_parent_link (line 213) | fn rewrite_parent_link(&mut self, leaf: &ProofTree) -> Result<()> {
    method rewrite_trunk_child_heights (line 239) | fn rewrite_trunk_child_heights(&mut self) -> Result<()> {
    method remaining_chunks_unchecked (line 288) | pub fn remaining_chunks_unchecked(&self) -> usize {
  method restore (line 302) | pub fn restore<P: AsRef<Path>>(
  method child_heights (line 312) | fn child_heights(&self) -> (u8, u8) {
  method as_link (line 321) | fn as_link(&self) -> Link {
  function restore_test (line 345) | fn restore_test(batches: &[&Batch], expected_nodes: usize) {
  function restore_10000 (line 382) | fn restore_10000() {
  function restore_3 (line 387) | fn restore_3() {
  function restore_2_left_heavy (line 392) | fn restore_2_left_heavy() {
  function restore_2_right_heavy (line 400) | fn restore_2_right_heavy() {
  function restore_1 (line 408) | fn restore_1() {
  function assert_raw_db_entries_eq (line 412) | fn assert_raw_db_entries_eq(restored: &Merk, original: &Merk, length: us...

FILE: src/merk/snapshot.rs
  type Snapshot (line 22) | pub struct Snapshot<'a> {
  function new (line 36) | pub fn new(db: rocksdb::Snapshot<'a>, tree: Option<Tree>) -> Self {
  function staticize (line 46) | pub fn staticize(mut self) -> StaticSnapshot {
  function get (line 57) | pub fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  function root_hash (line 66) | pub fn root_hash(&self) -> Hash {
  function prove (line 72) | pub fn prove<Q, I>(&self, query: I) -> Result<Vec<u8>>
  function walk (line 82) | pub fn walk<T>(&self, f: impl FnOnce(Option<RefWalker<SnapshotSource>>) ...
  function raw_iter (line 94) | pub fn raw_iter(&self) -> rocksdb::DBRawIterator {
  function source (line 100) | fn source(&self) -> SnapshotSource {
  function use_tree (line 105) | fn use_tree<T>(&self, f: impl FnOnce(Option<&Tree>) -> T) -> T {
  function use_tree_mut (line 113) | fn use_tree_mut<T>(&self, f: impl FnOnce(Option<&mut Tree>) -> T) -> T {
  method drop (line 122) | fn drop(&mut self) {
  type SnapshotSource (line 134) | pub struct SnapshotSource<'a>(&'a rocksdb::Snapshot<'a>);
  method fetch_by_key (line 137) | fn fetch_by_key(&self, key: &[u8]) -> Result<Option<Tree>> {
  type StaticSnapshot (line 157) | pub struct StaticSnapshot {
    method with_db (line 200) | pub unsafe fn with_db<'a>(&self, db: &'a rocksdb::DB) -> Snapshot<'a> {
    method drop (line 222) | pub unsafe fn drop(mut self, db: &rocksdb::DB) {
    method clone_tree (line 231) | fn clone_tree(&self) -> Cell<Option<Tree>> {
  type RocksDBSnapshot (line 175) | struct RocksDBSnapshot<'a> {
  method drop (line 243) | fn drop(&mut self) {
  method clone (line 251) | fn clone(&self) -> Self {
  function rocksdb_snapshot_struct_format (line 268) | fn rocksdb_snapshot_struct_format() {

FILE: src/owner.rs
  type Owner (line 5) | pub struct Owner<T> {
  function new (line 11) | pub fn new(value: T) -> Owner<T> {
  function own (line 33) | pub fn own<F: FnOnce(T) -> T>(&mut self, f: F) {
  function own_return (line 52) | pub fn own_return<R, F>(&mut self, f: F) -> R
  function own_fallible (line 76) | pub fn own_fallible<E, F: FnOnce(T) -> Result<T, E>>(&mut self, f: F) ->...
  function into_inner (line 84) | pub fn into_inner(mut self) -> T {
  type Target (line 90) | type Target = T;
  method deref (line 92) | fn deref(&self) -> &T {
  method deref_mut (line 98) | fn deref_mut(&mut self) -> &mut T {
  function unwrap (line 103) | fn unwrap<T>(option: Option<T>) -> T {

FILE: src/proofs/chunk.rs
  constant MIN_TRUNK_HEIGHT (line 18) | pub const MIN_TRUNK_HEIGHT: usize = 5;
  function create_trunk_proof (line 30) | pub fn create_trunk_proof(&mut self) -> Result<(Vec<Op>, bool)> {
  function traverse_for_height_proof (line 49) | fn traverse_for_height_proof(&mut self, proof: &mut Vec<Op>, depth: usiz...
  function traverse_for_trunk (line 78) | fn traverse_for_trunk(
  function get_next_chunk (line 127) | pub(crate) fn get_next_chunk(iter: &mut DBRawIterator, end_key: Option<&...
  function verify_leaf (line 177) | pub(crate) fn verify_leaf<I: Iterator<Item = Result<Op>>>(
  function verify_trunk (line 198) | pub(crate) fn verify_trunk<I: Iterator<Item = Result<Op>>>(ops: I) -> Re...
  type NodeCounts (line 286) | struct NodeCounts {
  function count_node_types (line 292) | fn count_node_types(tree: Tree) -> NodeCounts {
  function small_trunk_roundtrip (line 307) | fn small_trunk_roundtrip() {
  function big_trunk_roundtrip (line 324) | fn big_trunk_roundtrip() {
  function one_node_tree_trunk_roundtrip (line 343) | fn one_node_tree_trunk_roundtrip() -> Result<()> {
  function two_node_right_heavy_tree_trunk_roundtrip (line 360) | fn two_node_right_heavy_tree_trunk_roundtrip() -> Result<()> {
  function two_node_left_heavy_tree_trunk_roundtrip (line 380) | fn two_node_left_heavy_tree_trunk_roundtrip() -> Result<()> {
  function three_node_tree_trunk_roundtrip (line 400) | fn three_node_tree_trunk_roundtrip() -> Result<()> {
  function leaf_chunk_roundtrip (line 422) | fn leaf_chunk_roundtrip() {
  function test_verify_height_stack_overflow (line 480) | fn test_verify_height_stack_overflow() {

FILE: src/proofs/encoding.rs
  method encode_into (line 10) | fn encode_into<W: Write>(&self, dest: &mut W) -> ed::Result<()> {
  method encoding_length (line 35) | fn encoding_length(&self) -> ed::Result<usize> {
  method decode (line 47) | fn decode<R: Read>(mut input: R) -> ed::Result<Self> {
  method encode_into (line 84) | fn encode_into<W: Write>(&self, dest: &mut W) -> Result<()> {
  method encoding_length (line 88) | fn encoding_length(&self) -> usize {
  method decode (line 92) | pub fn decode(bytes: &[u8]) -> Result<Self> {
  function encode_into (line 97) | pub fn encode_into<'a, T: Iterator<Item = &'a Op>>(ops: T, output: &mut ...
  type Decoder (line 103) | pub struct Decoder<'a> {
  function new (line 109) | pub fn new(proof_bytes: &'a [u8]) -> Self {
  type Item (line 118) | type Item = Result<Op>;
  method next (line 120) | fn next(&mut self) -> Option<Self::Item> {
  function encode_push_hash (line 140) | fn encode_push_hash() {
  function encode_push_kvhash (line 157) | fn encode_push_kvhash() {
  function encode_push_kv (line 174) | fn encode_push_kv() {
  function encode_parent (line 184) | fn encode_parent() {
  function encode_child (line 194) | fn encode_child() {
  function encode_push_kv_long_key (line 205) | fn encode_push_kv_long_key() {
  function decode_push_hash (line 212) | fn decode_push_hash() {
  function decode_push_kvhash (line 222) | fn decode_push_kvhash() {
  function decode_push_kv (line 232) | fn decode_push_kv() {
  function decode_parent (line 239) | fn decode_parent() {
  function decode_child (line 246) | fn decode_child() {
  function decode_unknown (line 253) | fn decode_unknown() {

FILE: src/proofs/mod.rs
  type Op (line 14) | pub enum Op {
  type Node (line 32) | pub enum Node {

FILE: src/proofs/query/map.rs
  type MapBuilder (line 10) | pub(crate) struct MapBuilder(Map);
    method new (line 14) | pub fn new() -> Self {
    method insert (line 24) | pub fn insert(&mut self, node: &Node) -> Result<()> {
    method build (line 46) | pub fn build(self) -> Map {
  type Map (line 57) | pub struct Map {
    method get (line 67) | pub fn get<'a>(&'a self, key: &'a [u8]) -> Result<Option<&'a [u8]>> {
    method range (line 87) | pub fn range<'a>(&self, bounds: impl RangeBounds<&'a [u8]>) -> Range {
    method join (line 119) | pub fn join(self, other: Map) -> Map {
    method contiguous_right (line 145) | fn contiguous_right(&self, key: &[u8]) -> bool {
  function bound_to_inner (line 155) | fn bound_to_inner<T>(bound: Bound<T>) -> Option<T> {
  function bound_to_vec (line 163) | fn bound_to_vec(bound: Bound<&&[u8]>) -> Bound<Vec<u8>> {
  function bounds_to_vec (line 173) | fn bounds_to_vec<'a, R: RangeBounds<&'a [u8]>>(bounds: R) -> (Bound<Vec<...
  type Range (line 184) | pub struct Range<'a> {
  type InnerRange (line 191) | type InnerRange<'a> = btree_map::Range<'a, Vec<u8>, (bool, Vec<u8>)>;
  function yield_entry_if_contiguous (line 194) | fn yield_entry_if_contiguous(
  function yield_entry (line 208) | fn yield_entry(
  function yield_none_if_contiguous (line 222) | fn yield_none_if_contiguous(
  function yield_next_if_contiguous (line 235) | fn yield_next_if_contiguous(&mut self) -> Option<Result<(&'a [u8], &'a [...
  function yield_next_back_if_contiguous (line 246) | fn yield_next_back_if_contiguous(
  type Item (line 260) | type Item = Result<(&'a [u8], &'a [u8])>;
  method next (line 262) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 301) | fn next_back(&mut self) -> Option<Self::Item> {
  function mapbuilder_insert_out_of_order (line 347) | fn mapbuilder_insert_out_of_order() {
  function mapbuilder_insert_dupe (line 355) | fn mapbuilder_insert_dupe() {
  function mapbuilder_insert_including_edge (line 362) | fn mapbuilder_insert_including_edge() {
  function mapbuilder_insert_abridged_edge (line 371) | fn mapbuilder_insert_abridged_edge() {
  function mapbuilder_build (line 380) | fn mapbuilder_build() {
  function map_get_included (line 395) | fn map_get_included() {
  function map_get_missing_absence_proof (line 408) | fn map_get_missing_absence_proof() {
  function map_get_valid_absence_proof (line 419) | fn map_get_valid_absence_proof() {
  function range_abridged (line 430) | fn range_abridged() {
  function range_ok (line 443) | fn range_ok() {
  function range_empty (line 459) | fn range_empty() {
  function range_lower_unbounded_map_non_contiguous (line 468) | fn range_lower_unbounded_map_non_contiguous() {
  function range_reach_proof_end (line 482) | fn range_reach_proof_end() {
  function range_unbounded (line 495) | fn range_unbounded() {
  function range_abridged_rev (line 509) | fn range_abridged_rev() {
  function range_ok_rev (line 522) | fn range_ok_rev() {
  function range_upper_unbounded_map_non_contiguous (line 538) | fn range_upper_unbounded_map_non_contiguous() {
  function range_reach_proof_end_rev (line 552) | fn range_reach_proof_end_rev() {
  function range_unbounded_rev (line 565) | fn range_unbounded_rev() {
  function map_join (line 578) | fn map_join() {

FILE: src/proofs/query/mod.rs
  type Query (line 19) | pub struct Query {
    method new (line 25) | pub fn new() -> Self {
    method len (line 29) | pub(crate) fn len(&self) -> usize {
    method iter (line 33) | pub(crate) fn iter(&self) -> impl Iterator<Item = &QueryItem> {
    method insert_key (line 44) | pub fn insert_key(&mut self, key: Vec<u8>) {
    method insert_range (line 55) | pub fn insert_range(&mut self, range: std::ops::Range<Vec<u8>>) {
    method insert_range_inclusive (line 66) | pub fn insert_range_inclusive(&mut self, range: RangeInclusive<Vec<u8>...
    method insert_item (line 76) | pub fn insert_item(&mut self, mut item: QueryItem) {
    method from (line 89) | fn from(other: Vec<Q>) -> Self {
  function from (line 96) | fn from(q: Query) -> Vec<QueryItem> {
  type Item (line 102) | type Item = QueryItem;
  type IntoIter (line 103) | type IntoIter = <BTreeSet<QueryItem> as IntoIterator>::IntoIter;
  method into_iter (line 105) | fn into_iter(self) -> Self::IntoIter {
  type QueryItem (line 112) | pub enum QueryItem {
    method lower_bound (line 119) | pub fn lower_bound(&self) -> &[u8] {
    method upper_bound (line 127) | pub fn upper_bound(&self) -> (&[u8], bool) {
    method contains (line 135) | pub fn contains(&self, key: &[u8]) -> bool {
    method merge (line 140) | fn merge(self, other: QueryItem) -> QueryItem {
    method eq (line 162) | fn eq(&self, other: &&[u8]) -> bool {
    method partial_cmp (line 199) | fn partial_cmp(&self, other: &&[u8]) -> Option<Ordering> {
    method from (line 206) | fn from(key: Vec<u8>) -> Self {
  method eq (line 156) | fn eq(&self, other: &QueryItem) -> bool {
  method cmp (line 170) | fn cmp(&self, other: &QueryItem) -> Ordering {
  method partial_cmp (line 193) | fn partial_cmp(&self, other: &QueryItem) -> Option<Ordering> {
  method to_hash_node (line 215) | fn to_hash_node(&self) -> Node {
  function to_kv_node (line 233) | pub(crate) fn to_kv_node(&self) -> Node {
  function to_kvhash_node (line 239) | pub(crate) fn to_kvhash_node(&self) -> Node {
  function to_hash_node (line 244) | pub(crate) fn to_hash_node(&self) -> Node {
  function create_proof (line 253) | pub(crate) fn create_proof(
  function create_child_proof (line 319) | fn create_child_proof(
  function verify (line 340) | pub fn verify(bytes: &[u8], expected_hash: Hash) -> Result<Map> {
  function verify_query (line 364) | pub fn verify_query(
  function make_3_node_tree (line 479) | fn make_3_node_tree() -> Result<Tree> {
  function verify_keys_test (line 487) | fn verify_keys_test(keys: Vec<Vec<u8>>, expected_result: Vec<Option<Vec<...
  function root_verify (line 527) | fn root_verify() -> Result<()> {
  function single_verify (line 532) | fn single_verify() -> Result<()> {
  function double_verify (line 537) | fn double_verify() -> Result<()> {
  function double_verify_2 (line 542) | fn double_verify_2() -> Result<()> {
  function triple_verify (line 547) | fn triple_verify() -> Result<()> {
  function left_edge_absence_verify (line 555) | fn left_edge_absence_verify() -> Result<()> {
  function right_edge_absence_verify (line 560) | fn right_edge_absence_verify() -> Result<()> {
  function inner_absence_verify (line 565) | fn inner_absence_verify() -> Result<()> {
  function absent_and_present_verify (line 570) | fn absent_and_present_verify() -> Result<()> {
  function empty_proof (line 575) | fn empty_proof() -> Result<()> {
  function root_proof (line 618) | fn root_proof() -> Result<()> {
  function leaf_proof (line 660) | fn leaf_proof() -> Result<()> {
  function double_leaf_proof (line 702) | fn double_leaf_proof() -> Result<()> {
  function all_nodes_proof (line 738) | fn all_nodes_proof() -> Result<()> {
  function global_edge_absence_proof (line 775) | fn global_edge_absence_proof() -> Result<()> {
  function absence_proof (line 817) | fn absence_proof() -> Result<()> {
  function doc_proof (line 853) | fn doc_proof() -> Result<()> {
  function query_item_cmp (line 964) | fn query_item_cmp() {
  function query_item_merge (line 986) | fn query_item_merge() {
  function query_insert (line 1011) | fn query_insert() {
  function range_proof (line 1029) | fn range_proof() {
  function range_proof_inclusive (line 1116) | fn range_proof_inclusive() {
  function range_proof_missing_upper_bound (line 1204) | fn range_proof_missing_upper_bound() {
  function range_proof_missing_lower_bound (line 1291) | fn range_proof_missing_lower_bound() {
  function query_from_vec (line 1373) | fn query_from_vec() {
  function query_into_vec (line 1387) | fn query_into_vec() {
  function query_item_from_vec_u8 (line 1407) | fn query_item_from_vec_u8() {
  function verify_ops (line 1416) | fn verify_ops() -> Result<()> {
  function verify_ops_mismatched_hash (line 1440) | fn verify_ops_mismatched_hash() {
  function verify_query_mismatched_hash (line 1458) | fn verify_query_mismatched_hash() {
  function hash_attach (line 1484) | fn hash_attach() {

FILE: src/proofs/tree.rs
  type Child (line 8) | pub struct Child {
  type Tree (line 18) | pub struct Tree {
    method from (line 31) | fn from(node: Node) -> Self {
    method hash (line 52) | pub fn hash(&self) -> Result<Hash> {
    method layer (line 68) | pub fn layer(&self, depth: usize) -> LayerIter {
    method visit_nodes (line 74) | pub fn visit_nodes<F: FnMut(Node)>(mut self, visit_node: &mut F) {
    method visit_refs (line 89) | pub fn visit_refs<F: FnMut(&Tree)>(&self, visit_node: &mut F) {
    method child (line 102) | pub fn child(&self, left: bool) -> Option<&Child> {
    method child_mut (line 111) | pub(crate) fn child_mut(&mut self, left: bool) -> &mut Option<Child> {
    method attach (line 121) | pub(crate) fn attach(&mut self, left: bool, child: Tree) -> Result<()> {
    method child_hash (line 145) | fn child_hash(&self, left: bool) -> Hash {
    method try_into_hash (line 151) | fn try_into_hash(self) -> Result<Tree> {
    method key (line 156) | pub(crate) fn key(&self) -> &[u8] {
  method eq (line 43) | fn eq(&self, other: &Self) -> bool {
  type LayerIter (line 166) | pub struct LayerIter<'a> {
  function new (line 173) | fn new(tree: &'a Tree, depth: usize) -> Self {
  function traverse_to_start (line 185) | fn traverse_to_start(&mut self, tree: &'a Tree, remaining_depth: usize) {
  type Item (line 201) | type Item = &'a Tree;
  method next (line 203) | fn next(&mut self) -> Option<Self::Item> {
  function execute (line 245) | pub(crate) fn execute<I, F>(ops: I, collapse: bool, mut visit_node: F) -...
  function make_7_node_prooftree (line 321) | fn make_7_node_prooftree() -> ProofTree {
  function height_counting (line 338) | fn height_counting() {
  function layer_iter (line 356) | fn layer_iter() {
  function visit_nodes (line 382) | fn visit_nodes() {

FILE: src/test_utils/crash_merk.rs
  type CrashMerk (line 9) | pub struct CrashMerk {
    method open (line 17) | pub fn open<P: AsRef<Path>>(path: P) -> Result<CrashMerk> {
    method crash (line 27) | pub unsafe fn crash(&mut self) -> Result<()> {
    method into_inner (line 44) | pub fn into_inner(self) -> Merk {
    method destroy (line 48) | pub fn destroy(self) -> Result<()> {
  type Target (line 54) | type Target = Merk;
  method deref (line 56) | fn deref(&self) -> &Merk {
  method deref_mut (line 62) | fn deref_mut(&mut self) -> &mut Merk {
  function crash (line 74) | fn crash() {

FILE: src/test_utils/mod.rs
  function assert_tree_invariants (line 14) | pub fn assert_tree_invariants(tree: &Tree) {
  function apply_memonly_unchecked (line 37) | pub fn apply_memonly_unchecked(tree: Tree, batch: &Batch) -> Tree {
  function apply_memonly (line 47) | pub fn apply_memonly(tree: Tree, batch: &Batch) -> Tree {
  function apply_to_memonly (line 53) | pub fn apply_to_memonly(maybe_tree: Option<Tree>, batch: &Batch) -> Opti...
  function seq_key (line 66) | pub fn seq_key(n: u64) -> Vec<u8> {
  function put_entry_value (line 70) | pub fn put_entry_value() -> Vec<u8> {
  function put_entry (line 74) | pub fn put_entry(n: u64) -> BatchEntry {
  function del_entry (line 78) | pub fn del_entry(n: u64) -> BatchEntry {
  function make_batch_seq (line 82) | pub fn make_batch_seq(range: Range<u64>) -> Vec<BatchEntry> {
  function make_del_batch_seq (line 90) | pub fn make_del_batch_seq(range: Range<u64>) -> Vec<BatchEntry> {
  function make_batch_rand (line 98) | pub fn make_batch_rand(size: u64, seed: u64) -> Vec<BatchEntry> {
  function make_del_batch_rand (line 109) | pub fn make_del_batch_rand(size: u64, seed: u64) -> Vec<BatchEntry> {
  function make_tree_rand (line 120) | pub fn make_tree_rand(node_count: u64, batch_size: u64, initial_seed: u6...
  function make_tree_seq (line 139) | pub fn make_tree_seq(node_count: u64) -> Tree {

FILE: src/test_utils/temp_merk.rs
  type TempMerk (line 8) | pub struct TempMerk {
    method open (line 15) | pub fn open<P: AsRef<Path>>(path: P) -> Result<TempMerk> {
    method new (line 21) | pub fn new() -> Result<TempMerk> {
    method create_path (line 25) | pub fn create_path() -> PathBuf {
  method drop (line 37) | fn drop(&mut self) {
  type Target (line 47) | type Target = Merk;
  method deref (line 49) | fn deref(&self) -> &Merk {
  method deref_mut (line 55) | fn deref_mut(&mut self) -> &mut Merk {

FILE: src/tree/commit.rs
  type Commit (line 6) | pub trait Commit {
    method write (line 9) | fn write(&mut self, tree: &Tree) -> Result<()>;
    method prune (line 15) | fn prune(&self, _tree: &Tree) -> (bool, bool) {
    method write (line 24) | fn write(&mut self, _tree: &Tree) -> Result<()> {
    method prune (line 28) | fn prune(&self, _tree: &Tree) -> (bool, bool) {
  type NoopCommit (line 22) | pub struct NoopCommit {}

FILE: src/tree/debug.rs
  method fmt (line 7) | fn fmt(&self, f: &mut Formatter) -> Result {

FILE: src/tree/encoding.rs
  method encode (line 10) | pub fn encode(&self) -> Vec<u8> {
  method encode_into (line 16) | pub fn encode_into(&self, dest: &mut Vec<u8>) {
  method encoding_length (line 22) | pub fn encoding_length(&self) -> usize {
  method decode_into (line 28) | pub fn decode_into(&mut self, key: Vec<u8>, input: &[u8]) {
  method decode (line 35) | pub fn decode(key: Vec<u8>, input: &[u8]) -> Tree {
  method decode_v0 (line 42) | pub fn decode_v0<R: Read>(mut input: R) -> Result<Self> {
  function encode_leaf_tree (line 74) | fn encode_leaf_tree() {
  function encode_modified_tree (line 88) | fn encode_modified_tree() {
  function encode_loaded_tree (line 104) | fn encode_loaded_tree() -> Result<()> {
  function encode_uncommitted_tree (line 129) | fn encode_uncommitted_tree() -> Result<()> {
  function encode_reference_tree (line 154) | fn encode_reference_tree() {
  function decode_leaf_tree (line 179) | fn decode_leaf_tree() {
  function decode_reference_tree (line 190) | fn decode_reference_tree() {

FILE: src/tree/fuzz_tests.rs
  constant ITERATIONS (line 10) | const ITERATIONS: usize = 2_000;
  type Map (line 11) | type Map = BTreeMap<Vec<u8>, Vec<u8>>;
  function fuzz (line 14) | fn fuzz() {
  function fuzz_17391518417409062786 (line 24) | fn fuzz_17391518417409062786() {
  function fuzz_396148930387069749 (line 29) | fn fuzz_396148930387069749() {
  function fuzz_case (line 33) | fn fuzz_case(seed: u64) {
  function make_batch (line 59) | fn make_batch(maybe_tree: Option<&Tree>, size: u64, seed: u64) -> Vec<Ba...
  function apply_to_map (line 119) | fn apply_to_map(map: &mut Map, batch: &Batch) {
  function assert_map (line 132) | fn assert_map(maybe_tree: Option<&Tree>, map: &Map) {

FILE: src/tree/hash.rs
  type Hasher (line 5) | pub type Hasher = Sha512_256;
  constant HASH_LENGTH (line 8) | pub const HASH_LENGTH: usize = 32;
  constant NULL_HASH (line 11) | pub const NULL_HASH: Hash = [0; HASH_LENGTH];
  type Hash (line 14) | pub type Hash = [u8; HASH_LENGTH];
  function kv_hash (line 17) | pub fn kv_hash<D: Digest>(key: &[u8], value: &[u8]) -> Result<Hash, TryF...
  function node_hash (line 39) | pub fn node_hash<D: Digest>(kv: &Hash, left: &Hash, right: &Hash) -> Hash {

FILE: src/tree/iter.rs
  type StackItem (line 8) | struct StackItem<'a> {
  function new (line 17) | fn new(tree: &'a Tree) -> Self {
  function to_entry (line 29) | fn to_entry(&self) -> (Vec<u8>, Vec<u8>) {
  type Iter (line 36) | pub struct Iter<'a> {
  function new (line 42) | pub fn new(tree: &'a Tree) -> Self {
  method iter (line 51) | pub fn iter(&'a self) -> Iter<'a> {
  type Item (line 57) | type Item = (Vec<u8>, Vec<u8>);
  method next (line 60) | fn next(&mut self) -> Option<Self::Item> {

FILE: src/tree/kv.rs
  type KV (line 15) | pub struct KV {
    method new (line 24) | pub fn new(key: Vec<u8>, value: Vec<u8>) -> std::result::Result<Self, ...
    method from_fields (line 31) | pub fn from_fields(key: Vec<u8>, value: Vec<u8>, hash: Hash) -> Self {
    method with_value (line 38) | pub fn with_value(mut self, value: Vec<u8>) -> std::result::Result<Sel...
    method key (line 46) | pub fn key(&self) -> &[u8] {
    method value (line 52) | pub fn value(&self) -> &[u8] {
    method hash (line 58) | pub fn hash(&self) -> &Hash {
    method take_key (line 64) | pub fn take_key(self) -> Vec<u8> {
  method encode_into (line 71) | fn encode_into<W: Write>(&self, out: &mut W) -> Result<()> {
  method encoding_length (line 78) | fn encoding_length(&self) -> Result<usize> {
  method decode (line 90) | fn decode<R: Read>(input: R) -> Result<Self> {
  method decode_into (line 101) | fn decode_into<R: Read>(&mut self, mut input: R) -> Result<()> {
  function new_kv (line 118) | fn new_kv() -> std::result::Result<(), TryFromIntError> {
  function with_value (line 128) | fn with_value() -> std::result::Result<(), TryFromIntError> {

FILE: src/tree/link.rs
  type Link (line 14) | pub enum Link {
    method from_modified_tree (line 54) | pub fn from_modified_tree(tree: Tree) -> Self {
    method maybe_from_modified_tree (line 66) | pub fn maybe_from_modified_tree(maybe_tree: Option<Tree>) -> Option<Se...
    method is_reference (line 72) | pub fn is_reference(&self) -> bool {
    method is_modified (line 78) | pub fn is_modified(&self) -> bool {
    method is_uncommitted (line 84) | pub fn is_uncommitted(&self) -> bool {
    method is_stored (line 90) | pub fn is_stored(&self) -> bool {
    method key (line 96) | pub fn key(&self) -> &[u8] {
    method tree (line 108) | pub fn tree(&self) -> Option<&Tree> {
    method hash (line 122) | pub fn hash(&self) -> &Hash {
    method height (line 135) | pub fn height(&self) -> u8 {
    method balance_factor (line 147) | pub fn balance_factor(&self) -> i8 {
    method into_reference (line 160) | pub fn into_reference(self) -> Self {
    method child_heights_mut (line 179) | pub(crate) fn child_heights_mut(&mut self) -> &mut (u8, u8) {
    method default_reference (line 257) | fn default_reference() -> Self {
    method decode_v0 (line 265) | pub(crate) fn decode_v0<R: Read>(mut input: R) -> Result<Self> {
  method encode_into (line 203) | fn encode_into<W: Write>(&self, out: &mut W) -> Result<()> {
  method encoding_length (line 240) | fn encoding_length(&self) -> Result<usize> {
  method decode (line 287) | fn decode<R: Read>(input: R) -> Result<Link> {
  method decode_into (line 294) | fn decode_into<R: Read>(&mut self, mut input: R) -> Result<()> {
  function read_u16 (line 327) | fn read_u16<R: Read>(mut input: R) -> Result<u16> {
  function read_u8 (line 334) | fn read_u8<R: Read>(mut input: R) -> Result<u8> {
  function from_modified_tree (line 347) | fn from_modified_tree() -> std::result::Result<(), &'static str> {
  function maybe_from_modified_tree (line 362) | fn maybe_from_modified_tree() -> std::result::Result<(), crate::error::E...
  function types (line 373) | fn types() -> std::result::Result<(), crate::error::Error> {
  function modified_hash (line 438) | fn modified_hash() {
  function modified_into_reference (line 452) | fn modified_into_reference() {
  function uncommitted_into_reference (line 463) | fn uncommitted_into_reference() {
  function encode_link (line 473) | fn encode_link() {
  function encode_link_long_key_valid (line 493) | fn encode_link_long_key_valid() {
  function encode_link_long_key_invalid (line 508) | fn encode_link_long_key_invalid() {

FILE: src/tree/mod.rs
  type TreeInner (line 30) | pub struct TreeInner {
  type Tree (line 42) | pub struct Tree {
    method new (line 50) | pub fn new(key: Vec<u8>, value: Vec<u8>) -> Result<Self> {
    method from_fields (line 62) | pub fn from_fields(
    method key (line 80) | pub fn key(&self) -> &[u8] {
    method take_key (line 87) | pub fn take_key(self) -> Vec<u8> {
    method value (line 93) | pub fn value(&self) -> &[u8] {
    method kv_hash (line 99) | pub fn kv_hash(&self) -> &Hash {
    method link (line 106) | pub fn link(&self, left: bool) -> Option<&Link> {
    method link_mut (line 117) | pub fn link_mut(&mut self, left: bool) -> Option<&mut Link> {
    method child (line 128) | pub fn child(&self, left: bool) -> Option<&Self> {
    method child_mut (line 138) | pub fn child_mut(&mut self, left: bool) -> Option<&mut Self> {
    method child_hash (line 151) | pub fn child_hash(&self, left: bool) -> &Hash {
    method hash (line 157) | pub fn hash(&self) -> Hash {
    method child_pending_writes (line 168) | pub fn child_pending_writes(&self, left: bool) -> usize {
    method child_height (line 178) | pub fn child_height(&self, left: bool) -> u8 {
    method child_heights (line 183) | pub fn child_heights(&self) -> (u8, u8) {
    method height (line 191) | pub fn height(&self) -> u8 {
    method balance_factor (line 200) | pub fn balance_factor(&self) -> i8 {
    method attach (line 211) | pub fn attach(mut self, left: bool, maybe_child: Option<Self>) -> Self {
    method detach (line 237) | pub fn detach(mut self, left: bool) -> (Self, Option<Self>) {
    method detach_expect (line 257) | pub fn detach_expect(self, left: bool) -> (Self, Self) {
    method walk (line 279) | pub fn walk<F>(self, left: bool, f: F) -> Self
    method walk_expect (line 289) | pub fn walk_expect<F>(self, left: bool, f: F) -> Self
    method slot_mut (line 299) | pub(crate) fn slot_mut(&mut self, left: bool) -> &mut Option<Link> {
    method with_value (line 310) | pub fn with_value(mut self, value: Vec<u8>) -> Result<Self> {
    method commit (line 325) | pub fn commit<C: Commit>(&mut self, c: &mut C) -> Result<()> {
    method load (line 382) | pub fn load<S: Fetch>(&mut self, left: bool, source: &S) -> Result<()> {
    method get_value (line 405) | pub fn get_value(&self, key: &[u8]) -> Result<GetResult> {
  type GetResult (line 429) | pub enum GetResult {
  function side_to_str (line 435) | pub fn side_to_str(left: bool) -> &'static str {
  function build_tree (line 451) | fn build_tree() -> Result<()> {
  function attach_existing (line 476) | fn attach_existing() {
  function modify (line 490) | fn modify() -> Result<()> {
  function child_and_link (line 518) | fn child_and_link() -> Result<()> {
  function child_hash (line 537) | fn child_hash() -> Result<()> {
  function hash (line 553) | fn hash() -> Result<()> {
  function child_pending_writes (line 566) | fn child_pending_writes() -> Result<()> {
  function height_and_balance (line 578) | fn height_and_balance() -> Result<()> {
  function commit (line 601) | fn commit() -> Result<()> {

FILE: src/tree/ops.rs
  type Op (line 8) | pub enum Op {
    method fmt (line 16) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type BatchEntry (line 29) | pub type BatchEntry = (Vec<u8>, Op);
  type Batch (line 32) | pub type Batch = [BatchEntry];
  type PanicSource (line 37) | pub struct PanicSource {}
  method fetch_by_key (line 40) | fn fetch_by_key(&self, _: &[u8]) -> Result<Option<Tree>> {
  function apply_to (line 54) | pub fn apply_to(
  function build (line 75) | fn build(batch: &Batch, source: S) -> Result<Option<Tree>> {
  function apply (line 112) | fn apply(self, batch: &Batch) -> Result<(Option<Self>, LinkedList<Vec<u8...
  function recurse (line 164) | fn recurse(
  function balance_factor (line 210) | fn balance_factor(&self) -> i8 {
  function maybe_balance (line 217) | fn maybe_balance(self) -> Result<Self> {
  function rotate (line 237) | fn rotate(self, left: bool) -> Result<Self> {
  function remove (line 250) | pub fn remove(self) -> Result<Option<Self>> {
  function promote_edge (line 276) | fn promote_edge(self, left: bool, attach: Self) -> Result<Self> {
  function remove_edge (line 286) | fn remove_edge(self, left: bool) -> Result<(Self, Option<Self>)> {
  function simple_insert (line 309) | fn simple_insert() -> Result<()> {
  function simple_update (line 323) | fn simple_update() -> Result<()> {
  function simple_delete (line 339) | fn simple_delete() -> Result<()> {
  function delete_non_existent (line 366) | fn delete_non_existent() -> Result<()> {
  function delete_only_node (line 374) | fn delete_only_node() -> Result<()> {
  function delete_deep (line 387) | fn delete_deep() {
  function delete_recursive (line 399) | fn delete_recursive() {
  function delete_recursive_2 (line 412) | fn delete_recursive_2() {
  function rebalanced_delete (line 425) | fn rebalanced_delete() {
  function apply_empty_none (line 459) | fn apply_empty_none() {
  function insert_empty_single (line 467) | fn insert_empty_single() {
  function insert_root_single (line 479) | fn insert_root_single() -> Result<()> {
  function insert_root_double (line 490) | fn insert_root_double() -> Result<()> {
  function insert_rebalance (line 501) | fn insert_rebalance() -> Result<()> {
  function insert_100_sequential (line 517) | fn insert_100_sequential() -> Result<()> {
  function delete_recursive_large (line 532) | fn delete_recursive_large() {

FILE: src/tree/walk/fetch.rs
  type Fetch (line 8) | pub trait Fetch {
    method fetch_by_key (line 9) | fn fetch_by_key(&self, key: &[u8]) -> Result<Option<Tree>>;
    method fetch (line 13) | fn fetch(&self, link: &Link) -> Result<Tree> {
    method fetch_by_key_expect (line 17) | fn fetch_by_key_expect(&self, key: &[u8]) -> Result<Tree> {

FILE: src/tree/walk/mod.rs
  type Walker (line 12) | pub struct Walker<S>
  function new (line 25) | pub fn new(tree: Tree, source: S) -> Self {
  function detach (line 35) | pub fn detach(mut self, left: bool) -> Result<(Self, Option<Self>)> {
  function detach_expect (line 62) | pub fn detach_expect(self, left: bool) -> Result<(Self, Self)> {
  function walk (line 76) | pub fn walk<F, T>(self, left: bool, f: F) -> Result<Self>
  function walk_expect (line 89) | pub fn walk_expect<F, T>(self, left: bool, f: F) -> Result<Self>
  function tree (line 101) | pub fn tree(&self) -> &Tree {
  function into_inner (line 106) | pub fn into_inner(self) -> Tree {
  function wrap (line 112) | fn wrap(&self, tree: Tree) -> Self {
  function clone_source (line 117) | pub fn clone_source(&self) -> S {
  function attach (line 123) | pub fn attach<T>(mut self, left: bool, maybe_child: Option<T>) -> Self
  function with_value (line 133) | pub fn with_value(mut self, value: Vec<u8>) -> Result<Self> {
  method from (line 143) | fn from(walker: Walker<S>) -> Tree {
  type MockSource (line 155) | struct MockSource {}
  method fetch_by_key (line 158) | fn fetch_by_key(&self, key: &[u8]) -> Result<Option<Tree>> {
  function walk_modified (line 164) | fn walk_modified() -> Result<()> {
  function walk_stored (line 182) | fn walk_stored() -> Result<()> {
  function walk_pruned (line 201) | fn walk_pruned() {
  function walk_none (line 227) | fn walk_none() -> Result<()> {

FILE: src/tree/walk/ref_walker.rs
  type RefWalker (line 13) | pub struct RefWalker<'a, S>
  function new (line 26) | pub fn new(tree: &'a mut Tree, source: S) -> Self {
  function tree (line 32) | pub fn tree(&self) -> &Tree {
  function walk (line 39) | pub fn walk(&mut self, left: bool) -> Result<Option<RefWalker<S>>> {