Switch to parking_lot::Mutex and reexport it

Signed-off-by: trivernis <trivernis@protonmail.com>

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "bibliographix"
 description = "A bibliography management crate."
-version = "0.5.0"
+version = "0.6.0"
 authors = ["trivernis <trivernis@protonmail.com>"]
 edition = "2018"
 license = "Apache-2.0"
@@ -13,4 +13,5 @@ repository = "https://github.com/Trivernis/bibliographix"
 [dependencies]
 chrono = "0.4.15"
 chrono-english = "0.1.4"
-toml = "0.5.6"
+toml = "0.5.6"
+parking_lot = "0.11.1"

src/bib_manager.rs

@@ -3,11 +3,12 @@ use crate::bibliography::bibliography_entry::{BibliographyEntry, BibliographyEnt
 use crate::bibliography::keys::K_KEY;
 use crate::bibliography::FromHashMap;
 use crate::references::anchor::BibListAnchor;
+use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::io;
 use std::io::BufRead;
 use std::iter::FromIterator;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use toml::Value;
 
 /// The root manager for that should be used for further reference operations that
@@ -34,7 +35,7 @@ impl BibManager {
 
     /// Creates a new child BibManager with a child anchor and the parents entry dict
     pub fn create_child(&self) -> BibManager {
-        let anchor = self.root_ref_anchor.lock().unwrap().create_anchor();
+        let anchor = self.root_ref_anchor.lock().create_anchor();
         let entry_dict = Arc::clone(&self.entry_dictionary);
 
         Self {
@@ -50,13 +51,13 @@ impl BibManager {
 
     /// Assigns the corresponding bib entry to each bib reference
     pub fn assign_entries_to_references(&self) {
-        let entry_dict = self.entry_dictionary.lock().unwrap();
+        let entry_dict = self.entry_dictionary.lock();
-        let mut root_anchor = self.root_ref_anchor.lock().unwrap();
+        let mut root_anchor = self.root_ref_anchor.lock();
         root_anchor.flatten();
         let entries = root_anchor.references();
         entries.iter().for_each(|e| {
             if let Some(bib) = entry_dict.get(e.key()) {
-                e.anchor().lock().unwrap().entry = Some(bib)
+                e.anchor().lock().entry = Some(bib)
             }
         })
     }
@@ -65,9 +66,9 @@ impl BibManager {
     pub fn get_entry_list_by_occurrence(&self) -> Vec<BibliographyEntryReference> {
         let mut entries = Vec::new();
         let mut inserted_keys = Vec::new();
-        let entry_dict = self.entry_dictionary.lock().unwrap();
+        let entry_dict = self.entry_dictionary.lock();
 
-        for bib_ref in self.root_ref_anchor.lock().unwrap().references() {
+        for bib_ref in self.root_ref_anchor.lock().references() {
             if let Some(bib_entry) = entry_dict.get(bib_ref.key()) {
                 if !inserted_keys.contains(bib_ref.key()) {
                     entries.push(bib_entry);
@@ -84,7 +85,7 @@ impl BibManager {
         let mut contents = String::new();
         reader.read_to_string(&mut contents)?;
         let bib_content = contents.parse::<Value>()?;
-        let mut entry_dict = self.entry_dictionary.lock().unwrap();
+        let mut entry_dict = self.entry_dictionary.lock();
 
         if let Some(table) = bib_content.as_table() {
             let mut entries = table

src/bibliography/bibliography_dict.rs

@@ -1,8 +1,9 @@
 use crate::bibliography::bibliography_entry::{BibliographyEntry, BibliographyEntryReference};
 use crate::bibliography::keys::K_KEY;
 use crate::bibliography::FromHashMap;
+use parking_lot::Mutex;
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 /// A dictionary that contains all bibliography entries
 #[derive(Clone, Debug)]

src/bibliography/bibliography_entry.rs

@@ -2,9 +2,10 @@ use crate::bibliography::bib_types::misc::Misc;
 use crate::bibliography::bib_types::BibliographyType;
 use crate::bibliography::keys::{K_KEY, K_NOTE};
 use crate::bibliography::FromHashMap;
+use parking_lot::Mutex;
 use std::collections::hash_map::RandomState;
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 /// A single bibliography entry
 #[derive(Clone, Debug)]

src/lib.rs

@@ -3,6 +3,8 @@ pub mod bibliography;
 pub mod references;
 pub mod utils;
 
+pub use parking_lot::Mutex;
+
 #[cfg(test)]
 mod tests {
     use crate::bib_manager::BibManager;
@@ -15,17 +17,11 @@ mod tests {
     fn it_inserts_and_flattens() {
         let manager = BibManager::new();
         let root_anchor = manager.root_ref_anchor();
-        let mut root_anchor = root_anchor.lock().unwrap();
+        let mut root_anchor = root_anchor.lock();
         root_anchor.insert(BibRef::new("test".to_string()));
         let child_anchor = root_anchor.create_anchor();
-        child_anchor
+        child_anchor.lock().insert(BibRef::new("test2".to_string()));
-            .lock()
+        child_anchor.lock().insert(BibRef::new("test3".to_string()));
-            .unwrap()
-            .insert(BibRef::new("test2".to_string()));
-        child_anchor
-            .lock()
-            .unwrap()
-            .insert(BibRef::new("test3".to_string()));
         root_anchor.flatten();
 
         assert_eq!(root_anchor.references().len(), 3)
@@ -36,13 +32,13 @@ mod tests {
         let manager = BibManager::new();
         let ref1_1 = BibRef::new("ref1".to_string());
         let anchor1 = ref1_1.anchor();
-        manager.root_ref_anchor().lock().unwrap().insert(ref1_1);
+        manager.root_ref_anchor().lock().insert(ref1_1);
         let ref1_2 = BibRef::new("ref1".to_string());
         let anchor2 = ref1_2.anchor();
-        manager.root_ref_anchor().lock().unwrap().insert(ref1_2);
+        manager.root_ref_anchor().lock().insert(ref1_2);
         let ref3 = BibRef::new("ref2".to_string());
         let anchor3 = ref3.anchor();
-        manager.root_ref_anchor().lock().unwrap().insert(ref3);
+        manager.root_ref_anchor().lock().insert(ref3);
         let mut map: HashMap<String, String> = HashMap::new();
         map.insert("key".to_string(), "ref1".to_string());
         map.insert("type".to_string(), "article".to_string());
@@ -50,17 +46,12 @@ mod tests {
         map.insert("title".to_string(), "test_title".to_string());
         map.insert("journal".to_string(), "test_journal".to_string());
         map.insert("date".to_string(), "01.09.2020".to_string());
-        manager
+        manager.entry_dictionary().lock().insert_map(&map).unwrap();
-            .entry_dictionary()
-            .lock()
-            .unwrap()
-            .insert_map(&map)
-            .unwrap();
         manager.assign_entries_to_references();
 
-        assert!(anchor1.lock().unwrap().entry.is_some());
+        assert!(anchor1.lock().entry.is_some());
-        assert!(anchor2.lock().unwrap().entry.is_some());
+        assert!(anchor2.lock().entry.is_some());
-        assert!(anchor3.lock().unwrap().entry.is_none());
+        assert!(anchor3.lock().entry.is_none());
     }
 
     #[test]

src/references/anchor.rs

@@ -1,5 +1,6 @@
 use crate::references::bib_reference::BibRef;
-use std::sync::{Arc, Mutex};
+use parking_lot::Mutex;
+use std::sync::Arc;
 
 /// A bib list anchor that can be used to concurrently insert entries into a list
 #[derive(Clone, Debug)]
@@ -41,7 +42,7 @@ impl BibListAnchor {
         let mut new_entries = Vec::with_capacity(self.entries.len());
         self.entries.iter_mut().for_each(|e| match e {
             BibListEntry::Anchor(a) => {
-                let mut anchor = a.lock().unwrap();
+                let mut anchor = a.lock();
                 anchor.flatten();
                 new_entries.append(&mut anchor.entries);
             }

src/references/bib_reference.rs

@@ -1,5 +1,6 @@
 use crate::bibliography::bibliography_entry::BibliographyEntryReference;
-use std::sync::{Arc, Mutex};
+use parking_lot::Mutex;
+use std::sync::Arc;
 
 /// A reference to a bibliography entry
 #[derive(Clone, Debug)]