Implement some traits for rayon support.

Cargo.toml

@@ -4,11 +4,18 @@ version = "0.1.0"
 authors = ["logaritmisk <anders.e.olsson@gmail.com>"]
 
 [dependencies]
+rayon = "0.9"
 serde = "1.0"
 unreachable = "1.0"
 
 [dev-dependencies]
+criterion = { git = "https://github.com/japaric/criterion.rs.git" }
+rand = "0.4"
 serde_test = "1.0"
 
+[[bench]]
+name = "bench"
+harness = false
+
 [profile.release]
 lto = true

benches/bench.rs

@@ -0,0 +1,33 @@
+#[macro_use]
+extern crate criterion;
+extern crate rand;
+
+extern crate bit_set;
+
+use std::iter::FromIterator;
+
+use criterion::Criterion;
+use rand::{Rng, SeedableRng, XorShiftRng};
+
+use bit_set::BitSet;
+
+fn default_set<C: FromIterator<u64>>(n: usize) -> C {
+    let mut rng = XorShiftRng::from_seed([0, 1, 2, 3]);
+
+    (0..n).map(|_| rng.next_u64()).collect()
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let data: Vec<_> = default_set(1000);
+
+    c.bench_function("insert", |b| b.iter(|| {
+        let mut set = BitSet::new();
+
+        for v in &data {
+            set.insert(*v);
+        }
+    }));
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

src/lib.rs

@@ -1,3 +1,4 @@
+extern crate rayon;
 extern crate serde;
 extern crate unreachable;
 
@@ -5,7 +6,9 @@ use std::fmt;
 use std::ops;
 use std::iter::{FromIterator, IntoIterator, Iterator};
 use std::default::Default;
-use std::collections::HashMap;
+use std::collections::{HashMap, LinkedList};
+
+use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::ser::SerializeSeq;
@@ -330,6 +333,40 @@ impl Iterator for IntoIter {
     }
 }
 
+impl ParallelExtend<u64> for BitSet {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where I:
+        IntoParallelIterator<Item = u64>
+    {
+        let list = par_iter
+            .into_par_iter()
+            .fold(Vec::new, |mut vec, elem| {
+                vec.push(elem);
+                vec
+            })
+            .collect::<LinkedList<Vec<u64>>>();
+
+        let len = list.iter().map(Vec::len).sum();
+
+        let mut set = BitSet::with_capacity(len);
+
+        for vec in list {
+            set.extend(vec);
+        }
+    }
+}
+
+impl FromParallelIterator<u64> for BitSet {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = u64>
+    {
+        let mut set = BitSet::new();
+        set.par_extend(par_iter);
+        set
+    }
+}
+
 impl Serialize for BitSet {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>