      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120

    // Copyright 2015-2017 Parity Technologies (UK) Ltd.
    // This file is part of Parity.

    // Parity is free software: you can redistribute it and/or modify
    // it under the terms of the GNU General Public License as published by
    // the Free Software Foundation, either version 3 of the License, or
    // (at your option) any later version.

    // Parity is distributed in the hope that it will be useful,
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    // GNU General Public License for more details.

    // You should have received a copy of the GNU General Public License
    // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

    //! Key-value datastore with a modified Merkle tree.
    extern crate rand;

    use bytes::*;
    use sha3::*;
    use hash::*;
    use rlp::encode;

    /// Alphabet to use when creating words for insertion into tries.
    pub enum Alphabet {
    	/// All values are allowed in each bytes of the key.
    	All,
    	/// Only a 6 values ('a' - 'f') are chosen to compose the key.
    	Low,
    	/// Quite a few values (around 32) are chosen to compose the key.
    	Mid,
    	/// A set of bytes given is used to compose the key.
    	Custom(Bytes),
    }

    /// Means of determining the value.
    pub enum ValueMode {
    	/// Same as the key.
    	Mirror,
    	/// Randomly (50:50) 1 or 32 byte randomly string.
    	Random,
    	/// RLP-encoded index.
    	Index,
    }

    /// Standard test map for profiling tries.
    pub struct StandardMap {
    	/// The alphabet to use for keys.
    	pub alphabet: Alphabet,
    	/// Minimum size of key.
    	pub min_key: usize,
    	/// Delta size of key.
    	pub journal_key: usize,
    	/// Mode of value generation.
    	pub value_mode: ValueMode,
    	/// Number of keys.
    	pub count: usize,
    }

    impl StandardMap {
    	/// Get a bunch of random bytes, at least `min_count` bytes, at most `min_count` + `journal_count` bytes.
    	/// `seed` is mutated pseudoramdonly and used.
    	fn random_bytes(min_count: usize, journal_count: usize, seed: &mut H256) -> Vec<u8> {
    		assert!(min_count + journal_count <= 32);
    		*seed = seed.sha3();
    		let r = min_count + (seed[31] as usize % (journal_count + 1));
    		seed[0..r].to_vec()
    	}

    	/// Get a random value. Equal chance of being 1 byte as of 32. `seed` is mutated pseudoramdonly and used.
    	fn random_value(seed: &mut H256) -> Bytes {
    		*seed = seed.sha3();
    		match seed[0] % 2 {
    			1 => vec![seed[31];1],
    			_ => seed.to_vec(),
    		}
    	}

    	/// Get a random word of, at least `min_count` bytes, at most `min_count` + `journal_count` bytes.
    	/// Each byte is an item from `alphabet`. `seed` is mutated pseudoramdonly and used.
    	fn random_word(alphabet: &[u8], min_count: usize, journal_count: usize, seed: &mut H256) -> Vec<u8> {
    		assert!(min_count + journal_count <= 32);
    		*seed = seed.sha3();
    		let r = min_count + (seed[31] as usize % (journal_count + 1));
    		let mut ret: Vec<u8> = Vec::with_capacity(r);
    		for i in 0..r {
    			ret.push(alphabet[seed[i] as usize % alphabet.len()]);
    		}
    		ret
    	}

    	/// Create the standard map (set of keys and values) for the object's fields.
    	pub fn make(&self) -> Vec<(Bytes, Bytes)> {
    		self.make_with(&mut H256::new())
    	}

    	/// Create the standard map (set of keys and values) for the object's fields, using the given seed.
    	pub fn make_with(&self, seed: &mut H256) -> Vec<(Bytes, Bytes)> {
    		let low = b"abcdef";
    		let mid = b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_";

    		let mut d: Vec<(Bytes, Bytes)> = Vec::new();
    		for index in 0..self.count {
    			let k = match self.alphabet {
    				Alphabet::All => Self::random_bytes(self.min_key, self.journal_key, seed),
    				Alphabet::Low => Self::random_word(low, self.min_key, self.journal_key, seed),
    				Alphabet::Mid => Self::random_word(mid, self.min_key, self.journal_key, seed),
    				Alphabet::Custom(ref a) => Self::random_word(a, self.min_key, self.journal_key, seed),
    			};
    			let v = match self.value_mode {
    				ValueMode::Mirror => k.clone(),
    				ValueMode::Random => Self::random_value(seed),
    				ValueMode::Index => encode(&index).to_vec(),
    			};
    			d.push((k, v))
    		}
    		d
    	}
    }

# 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`)