SYMBOL INDEX (158 symbols across 5 files)

FILE: benches/build.rs
  function build1_ser (line 9) | fn build1_ser(bench: &mut Bencher) {
  function build1_par (line 17) | fn build1_par(bench: &mut Bencher) {
  function scan1_ser (line 25) | fn scan1_ser(bench: &mut Bencher) {

FILE: src/bitvector.rs
  type Word (line 35) | type Word = AtomicU64;
  type Word (line 38) | type Word = u64;
  type BitVector (line 43) | pub struct BitVector {
    method clone (line 102) | fn clone(&self) -> Self {
    method fmt (line 118) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method new (line 139) | pub fn new(bits: u64) -> Self {
    method ones (line 157) | pub fn ones(bits: u64) -> Self {
    method is_empty (line 179) | pub fn is_empty(&self) -> bool {
    method len (line 188) | pub fn len(&self) -> u64 {
    method contains (line 211) | pub fn contains(&self, bit: u64) -> bool {
    method eq_left (line 219) | pub fn eq_left(&self, other: &BitVector, bit: u64) -> bool {
    method insert (line 253) | pub fn insert(&self, bit: u64) -> bool {
    method insert (line 263) | pub fn insert(&mut self, bit: u64) -> bool {
    method insert_sync (line 282) | pub fn insert_sync(&mut self, bit: u64) -> bool {
    method remove (line 301) | pub fn remove(&self, bit: u64) -> bool {
    method remove (line 310) | pub fn remove(&mut self, bit: u64) -> bool {
    method insert_all (line 325) | pub fn insert_all(&self, all: &BitVector) -> bool {
    method insert_all (line 342) | pub fn insert_all(&mut self, all: &BitVector) -> bool {
    method capacity (line 359) | pub fn capacity(&self) -> u64 {
    method get_word (line 364) | pub fn get_word(&self, word: usize) -> u64 {
    method num_words (line 372) | pub fn num_words(&self) -> usize {
    method iter (line 377) | pub fn iter(&self) -> BitVectorIter<'_> {
  function ser_atomic_vec (line 58) | fn ser_atomic_vec<S>(v: &[AtomicU64], serializer: S) -> Result<S::Ok, S:...
  function de_atomic_vec (line 72) | pub fn de_atomic_vec<'de, D>(deserializer: D) -> Result<Box<[AtomicU64]>...
  method eq (line 132) | fn eq(&self, other: &BitVector) -> bool {
  type BitVectorIter (line 388) | pub struct BitVectorIter<'a> {
  type Item (line 396) | type Item = u64;
  method next (line 397) | fn next(&mut self) -> Option<u64> {
  function u64s (line 426) | fn u64s(elements: u64) -> u64 {
  function word_offset (line 430) | fn word_offset(index: u64) -> (u64, u64) {
  function word_mask (line 435) | fn word_mask(index: u64) -> (usize, u64) {
  function union_two_vecs (line 445) | fn union_two_vecs() {
  function bitvec_iter_works (line 464) | fn bitvec_iter_works() {
  function bitvec_iter_works_2 (line 483) | fn bitvec_iter_works_2() {
  function eq_left (line 495) | fn eq_left() {
  function eq (line 520) | fn eq() {
  function remove (line 543) | fn remove() {
  function is_empty (line 559) | fn is_empty() {
  function test_ones (line 580) | fn test_ones() {
  function len (line 589) | fn len() {
  function bench_bitset_operator (line 611) | fn bench_bitset_operator(b: &mut Bencher) {
  function bench_bitset_operator_inplace (line 630) | fn bench_bitset_operator_inplace(b: &mut Bencher) {
  function bench_hashset_operator (line 649) | fn bench_hashset_operator(b: &mut Bencher) {
  function bench_btreeset_operator (line 669) | fn bench_btreeset_operator(b: &mut Bencher) {

FILE: src/hashmap.rs
  type BoomHashMap (line 16) | pub struct BoomHashMap<K: Hash, D> {
  function create_map (line 27) | fn create_map(mut keys: Vec<K>, mut values: Vec<D>, mphf: Mphf<K>) -> Bo...
  function new (line 43) | pub fn new(keys: Vec<K>, data: Vec<D>) -> BoomHashMap<K, D> {
  function get (line 49) | pub fn get<Q: ?Sized>(&self, kmer: &Q) -> Option<&D>
  function get_mut (line 69) | pub fn get_mut<Q: ?Sized>(&mut self, kmer: &Q) -> Option<&mut D>
  function get_key_id (line 89) | pub fn get_key_id<Q: ?Sized>(&self, kmer: &Q) -> Option<usize>
  function len (line 109) | pub fn len(&self) -> usize {
  function is_empty (line 113) | pub fn is_empty(&self) -> bool {
  function get_key (line 117) | pub fn get_key(&self, id: usize) -> Option<&K> {
  function iter (line 126) | pub fn iter(&self) -> BoomIterator<K, D> {
  function from_iter (line 139) | fn from_iter<I: IntoIterator<Item = (K, D)>>(iter: I) -> Self {
  type ConstructibleKey (line 152) | pub trait ConstructibleKey: Hash + Debug + PartialEq + Send + Sync {}
  type ConstructibleKey (line 158) | pub trait ConstructibleKey: Hash + Debug + PartialEq {}
  function new_parallel (line 170) | pub fn new_parallel(keys: Vec<K>, data: Vec<D>) -> BoomHashMap<K, D> {
  type BoomIterator (line 177) | pub struct BoomIterator<'a, K: Hash + 'a, D: 'a> {
  type Item (line 183) | type Item = (&'a K, &'a D);
  method next (line 185) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 196) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 205) | type Item = (&'a K, &'a D);
  type IntoIter (line 206) | type IntoIter = BoomIterator<'a, K, D>;
  method into_iter (line 208) | fn into_iter(self) -> BoomIterator<'a, K, D> {
  type BoomHashMap2 (line 222) | pub struct BoomHashMap2<K: Hash, D1, D2> {
  type Boom2Iterator (line 229) | pub struct Boom2Iterator<'a, K: Hash + 'a, D1: 'a, D2: 'a> {
  type Item (line 235) | type Item = (&'a K, &'a D1, &'a D2);
  method next (line 237) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 251) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 260) | type Item = (&'a K, &'a D1, &'a D2);
  type IntoIter (line 261) | type IntoIter = Boom2Iterator<'a, K, D1, D2>;
  method into_iter (line 263) | fn into_iter(self) -> Boom2Iterator<'a, K, D1, D2> {
  function create_map (line 277) | fn create_map(
  function new (line 305) | pub fn new(keys: Vec<K>, values: Vec<D1>, aux_values: Vec<D2>) -> BoomHa...
  function get (line 310) | pub fn get<Q: ?Sized>(&self, kmer: &Q) -> Option<(&D1, &D2)>
  function get_mut (line 329) | pub fn get_mut<Q: ?Sized>(&mut self, kmer: &Q) -> Option<(&mut D1, &mut ...
  function get_key_id (line 351) | pub fn get_key_id<Q: ?Sized>(&self, kmer: &Q) -> Option<usize>
  function len (line 370) | pub fn len(&self) -> usize {
  function is_empty (line 374) | pub fn is_empty(&self) -> bool {
  function iter (line 379) | pub fn iter(&self) -> Boom2Iterator<K, D1, D2> {
  function get_key (line 386) | pub fn get_key(&self, id: usize) -> Option<&K> {
  function from_iter (line 402) | fn from_iter<I: IntoIterator<Item = (K, D1, D2)>>(iter: I) -> Self {
  function new_parallel (line 424) | pub fn new_parallel(keys: Vec<K>, data: Vec<D1>, aux_data: Vec<D2>) -> B...
  type NoKeyBoomHashMap (line 434) | pub struct NoKeyBoomHashMap<K, D1> {
  function from_iter (line 444) | fn from_iter<I: IntoIterator<Item = (K, D1)>>(iter: I) -> Self {
  function create_map (line 466) | fn create_map(mut keys: Vec<K>, mut values: Vec<D1>, mphf: Mphf<K>) -> N...
  function new (line 483) | pub fn new(keys: Vec<K>, data: Vec<D1>) -> NoKeyBoomHashMap<K, D1> {
  function new_parallel (line 490) | pub fn new_parallel(keys: Vec<K>, values: Vec<D1>) -> NoKeyBoomHashMap<K...
  function new_with_mphf (line 495) | pub fn new_with_mphf(mphf: Mphf<K>, values: Vec<D1>) -> NoKeyBoomHashMap...
  function get (line 500) | pub fn get<Q: ?Sized>(&self, kmer: &Q) -> Option<&D1>
  function get_mut (line 513) | pub fn get_mut<Q: ?Sized>(&mut self, kmer: &Q) -> Option<&mut D1>
  type NoKeyBoomHashMap2 (line 530) | pub struct NoKeyBoomHashMap2<K, D1, D2> {
  function from_iter (line 542) | fn from_iter<I: IntoIterator<Item = (K, D1, D2)>>(iter: I) -> Self {
  function create_map (line 567) | fn create_map(
  function new (line 591) | pub fn new(keys: Vec<K>, values: Vec<D1>, aux_values: Vec<D2>) -> NoKeyB...
  function new_parallel (line 597) | pub fn new_parallel(
  function new_with_mphf (line 606) | pub fn new_with_mphf(
  function get (line 619) | pub fn get<Q: ?Sized>(&self, kmer: &Q) -> Option<(&D1, &D2)>
  function get_mut (line 629) | pub fn get_mut<Q: ?Sized>(&mut self, kmer: &Q) -> Option<(&mut D1, &mut ...

FILE: src/lib.rs
  function fold (line 56) | fn fold(v: u64) -> u32 {
  function hash_with_seed (line 61) | fn hash_with_seed<T: Hash + ?Sized>(iter: u64, v: &T) -> u64 {
  function hash_with_seed32 (line 68) | fn hash_with_seed32<T: Hash + ?Sized>(iter: u64, v: &T) -> u32 {
  function fastmod (line 73) | fn fastmod(hash: u32, n: u32) -> u64 {
  function hashmod (line 78) | fn hashmod<T: Hash + ?Sized>(iter: u64, v: &T, n: u64) -> u64 {
  type Mphf (line 93) | pub struct Mphf<T> {
  constant MAX_ITERS (line 98) | const MAX_ITERS: u64 = 100;
  function from_chunked_iterator (line 112) | pub fn from_chunked_iterator<I, N>(gamma: f64, objects: &'a I, n: u64) -...
  function new (line 235) | pub fn new(gamma: f64, objects: &[T]) -> Mphf<T> {
  function compute_ranks (line 277) | fn compute_ranks(bvs: Vec<BitVector>) -> Box<[(BitVector, Box<[u64]>)]> {
  function get_rank (line 300) | fn get_rank(&self, hash: u64, i: usize) -> u64 {
  function hash (line 324) | pub fn hash(&self, item: &T) -> u64 {
  function try_hash (line 340) | pub fn try_hash<Q>(&self, item: &Q) -> Option<u64>
  function new_parallel (line 363) | pub fn new_parallel(gamma: f64, objects: &[T], starting_seed: Option<u64...
  type Context (line 411) | struct Context {
    method new (line 419) | fn new(size: u64, seed: u64) -> Self {
    method find_collisions (line 429) | fn find_collisions<T: Hash>(&self, v: &T) {
    method find_collisions_sync (line 436) | fn find_collisions_sync<T: Hash>(&mut self, v: &T) {
    method filter (line 444) | fn filter<'t, T: Hash>(&self, v: &'t T) -> Option<&'t T> {
    method filter (line 455) | fn filter<'t, T: Hash>(&mut self, v: &'t T) -> Option<&'t T> {
  type Queue (line 467) | struct Queue<'a, I: 'a, T>
  function new (line 490) | fn new(keys_object: &'a I, num_keys: u64) -> Queue<'a, I, T> {
  function next (line 504) | fn next(&mut self, done_keys_count: &AtomicU64) -> Option<(N2, u8, u64, ...
  function from_chunked_iterator_parallel (line 539) | pub fn from_chunked_iterator_parallel<I, N>(
  type IterContext (line 671) | struct IterContext<'a, I: 'a, N1, N2, T>
  type GlobalContext (line 684) | struct GlobalContext<T> {
  function check_mphf (line 702) | fn check_mphf<T>(xs: HashSet<T>) -> bool
  function check_mphf_serial (line 713) | fn check_mphf_serial<T>(xsv: &[T]) -> bool
  function check_mphf_parallel (line 732) | fn check_mphf_parallel<T>(xsv: &[T]) -> bool
  function check_mphf_parallel (line 750) | fn check_mphf_parallel<T>(_xsv: &[T]) -> bool
  function check_chunked_mphf (line 757) | fn check_chunked_mphf<T>(values: Vec<Vec<T>>, total: u64) -> bool
  function check_chunked_mphf_parallel (line 777) | fn check_chunked_mphf_parallel<T>(values: Vec<Vec<T>>, total: u64) -> bool
  function check_chunked_mphf_parallel (line 797) | fn check_chunked_mphf_parallel<T>(_values: Vec<Vec<T>>, _total: u64) -> ...
  function check_crossbeam_scope (line 807) | fn check_crossbeam_scope() {
  function from_ints_serial (line 882) | fn from_ints_serial() {

FILE: src/par_iter.rs
  type Item (line 12) | type Item = (&'data K, &'data V);
  type Iter (line 13) | type Iter = Iter<'data, K, V>;
  method into_par_iter (line 15) | fn into_par_iter(self) -> Self::Iter {
  type Iter (line 25) | pub struct Iter<'data, K, V> {
  type Item (line 35) | type Item = (&'data K, &'data V);
  method drive_unindexed (line 37) | fn drive_unindexed<C>(self, consumer: C) -> C::Result
  method opt_len (line 44) | fn opt_len(&self) -> Option<usize> {
  method drive (line 54) | fn drive<C>(self, consumer: C) -> C::Result
  method len (line 61) | fn len(&self) -> usize {
  method with_producer (line 65) | fn with_producer<CB>(self, callback: CB) -> CB::Output
  type IterProducer (line 76) | struct IterProducer<'data, K, V> {
  type Item (line 86) | type Item = (&'data K, &'data V);
  type IntoIter (line 87) | type IntoIter = KeyValIter<'data, K, V>;
  method into_iter (line 89) | fn into_iter(self) -> Self::IntoIter {
  method split_at (line 96) | fn split_at(self, index: usize) -> (Self, Self) {
  type KeyValIter (line 112) | struct KeyValIter<'data, K, V> {
  type Item (line 118) | type Item = (&'data K, &'data V);
  method next (line 120) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 130) | fn size_hint(&self) -> (usize, Option<usize>) {
  method next_back (line 138) | fn next_back(&mut self) -> Option<Self::Item> {