diff --git a/Cargo.toml b/Cargo.toml index 7d55f07..e68a26b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "bibliographix" description = "A bibliography management crate." -version = "0.5.0" +version = "0.6.0" authors = ["trivernis "] 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" \ No newline at end of file +toml = "0.5.6" +parking_lot = "0.11.1" \ No newline at end of file diff --git a/src/bib_manager.rs b/src/bib_manager.rs index 3e0096a..ccb9914 100644 --- a/src/bib_manager.rs +++ b/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 mut root_anchor = self.root_ref_anchor.lock().unwrap(); + let entry_dict = self.entry_dictionary.lock(); + 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 { 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::()?; - 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 diff --git a/src/bibliography/bibliography_dict.rs b/src/bibliography/bibliography_dict.rs index 70c57c9..15cc733 100644 --- a/src/bibliography/bibliography_dict.rs +++ b/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)] diff --git a/src/bibliography/bibliography_entry.rs b/src/bibliography/bibliography_entry.rs index 53d807c..4d2fa9e 100644 --- a/src/bibliography/bibliography_entry.rs +++ b/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)] diff --git a/src/lib.rs b/src/lib.rs index 182b758..90f9b87 100644 --- a/src/lib.rs +++ b/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 - .lock() - .unwrap() - .insert(BibRef::new("test2".to_string())); - child_anchor - .lock() - .unwrap() - .insert(BibRef::new("test3".to_string())); + child_anchor.lock().insert(BibRef::new("test2".to_string())); + child_anchor.lock().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 = 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 - .entry_dictionary() - .lock() - .unwrap() - .insert_map(&map) - .unwrap(); + manager.entry_dictionary().lock().insert_map(&map).unwrap(); manager.assign_entries_to_references(); - assert!(anchor1.lock().unwrap().entry.is_some()); - assert!(anchor2.lock().unwrap().entry.is_some()); - assert!(anchor3.lock().unwrap().entry.is_none()); + assert!(anchor1.lock().entry.is_some()); + assert!(anchor2.lock().entry.is_some()); + assert!(anchor3.lock().entry.is_none()); } #[test] diff --git a/src/references/anchor.rs b/src/references/anchor.rs index c0746fc..50d6e9c 100644 --- a/src/references/anchor.rs +++ b/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); } diff --git a/src/references/bib_reference.rs b/src/references/bib_reference.rs index 33b8d7c..ef6a47c 100644 --- a/src/references/bib_reference.rs +++ b/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)]