expose static Manager singleton to consumers

Cargo.toml

@@ -14,6 +14,7 @@ backtrace = ["failure/backtrace", "failure/std"]
 [dependencies]
 arrayref = "0.3"
 bincode = "0.9"
+lazy_static = "1.0"
 lmdb = "0.7"
 ordered-float = "0.5"
 uuid = "0.5"

src/lib.rs

@@ -12,6 +12,7 @@
 
 #[macro_use] extern crate arrayref;
 #[macro_use] extern crate failure;
+#[macro_use] extern crate lazy_static;
 
 extern crate bincode;
 extern crate lmdb;
@@ -48,7 +49,7 @@ pub use integer::{
 };
 
 pub use manager::{
- Manager,
+ MANAGER,
 };
 
 pub use readwrite::{

src/manager.rs

@@ -23,7 +23,6 @@ use std::path::{
 
 use std::sync::{
  Arc,
- Mutex,
  RwLock,
 };
 
@@ -35,31 +34,36 @@ use ::Rkv;
 
 /// A process is only permitted to have one open handle to each database. This manager
 /// exists to enforce that constraint: don't open databases directly.
+lazy_static! {
+ pub static ref MANAGER: RwLock<Manager> = {
+ RwLock::new(Manager::new())
+ };
+}
+
 pub struct Manager {
- stores: Mutex<BTreeMap<PathBuf, Arc<RwLock<Rkv>>>>,
+ stores: BTreeMap<PathBuf, Arc<RwLock<Rkv>>>,
 }
 
 impl Manager {
- pub fn new() -> Manager {
+ fn new() -> Manager {
  Manager {
- stores: Mutex::new(Default::default()),
+ stores: Default::default(),
  }
  }
 
  /// Return the open store at `path`, returning `None` if it has not already been opened.
  pub fn get<'p, P>(&self, path: P) -> Result<Option<Arc<RwLock<Rkv>>>, ::std::io::Error>
  where P: Into<&'p Path> {
  let canonical = path.into().canonicalize()?;
- Ok(self.stores.lock().unwrap().get(&canonical).cloned())
+ Ok(self.stores.get(&canonical).cloned())
  }
 
  /// Return the open store at `path`, or create it by calling `f`.
  pub fn get_or_create<'p, F, P>(&mut self, path: P, f: F) -> Result<Arc<RwLock<Rkv>>, StoreError>
  where F: FnOnce(&Path) -> Result<Rkv, StoreError>,
  P: Into<&'p Path> {
  let canonical = path.into().canonicalize()?;
- let mut map = self.stores.lock().unwrap();
- Ok(match map.entry(canonical) {
+ Ok(match self.stores.entry(canonical) {
  Entry::Occupied(e) => e.get().clone(),
  Entry::Vacant(e) => {
  let k = Arc::new(RwLock::new(f(e.key().as_path())?));

tests/manager.rs

@@ -2,7 +2,7 @@ extern crate rkv;
 extern crate tempdir;
 
 use rkv::{
- Manager,
+ MANAGER,
  Rkv,
 };
 
@@ -16,17 +16,15 @@ use std::sync::{
 
 #[test]
 // Identical to the same-named unit test, but this one confirms that it works
-// via public Manager APIs.
+// via the public MANAGER singleton.
 fn test_same() {
- let root = TempDir::new("test_same").expect("tempdir");
+ let root = TempDir::new("test_same_singleton").expect("tempdir");
  fs::create_dir_all(root.path()).expect("dir created");
 
- let mut manager = Manager::new();
-
  let p = root.path();
- assert!(manager.get(p).expect("success").is_none());
+ assert!(MANAGER.read().unwrap().get(p).expect("success").is_none());
 
- let created_arc = manager.get_or_create(p, Rkv::new).expect("created");
- let fetched_arc = manager.get(p).expect("success").expect("existed");
+ let created_arc = MANAGER.write().unwrap().get_or_create(p, Rkv::new).expect("created");
+ let fetched_arc = MANAGER.read().unwrap().get(p).expect("success").expect("existed");
  assert!(Arc::ptr_eq(&created_arc, &fetched_arc));
 }