use std::{
ops::Index,
sync::{Arc, LazyLock},
};
use hashbrown::{DefaultHashBuilder, HashMap};
use indexmap::IndexMap;
use crate::{
DictWordMetadata,
spell::{
dictionary::{ANNOTATIONS_STR, CURATED_DICT_STR},
rune::{self, AttributeList, parse_word_list},
word_id::{CanonicalWordId, CaseFoldedWordId},
},
};
pub mod word_map_entry;
pub use word_map_entry::WordMapEntry;
type CanonicalStorage = IndexMap<CanonicalWordId, WordMapEntry, DefaultHashBuilder>;
#[derive(Debug, Clone, Eq, PartialEq, Default)]
pub struct WordMap {
canonical: CanonicalStorage,
case_folded: HashMap<CaseFoldedWordId, Vec<usize>>,
}
impl WordMap {
pub fn new() -> Self {
Default::default()
}
pub fn curated() -> Arc<Self> {
static CURATED: LazyLock<Arc<WordMap>> = LazyLock::new(|| {
Arc::new(WordMap::from_rune_files(CURATED_DICT_STR, ANNOTATIONS_STR).unwrap())
});
(*CURATED).clone()
}
pub fn contains_canonical(&self, id: CanonicalWordId) -> bool {
self.get_canonical(id).is_some()
}
pub fn contains_case_folded(&self, id: CaseFoldedWordId) -> bool {
!self.get_canonical_indices_from_case_folded(id).is_empty()
}
pub fn get_canonical(&self, id: CanonicalWordId) -> Option<&WordMapEntry> {
self.canonical.get(&id)
}
pub fn get_case_folded(
&self,
id: CaseFoldedWordId,
) -> impl ExactSizeIterator<Item = &WordMapEntry> {
self.get_canonical_indices_from_case_folded(id)
.iter()
.map(|canonical_index| &self[*canonical_index])
}
pub fn get_case_folded_chars(
&self,
word: &[char],
) -> impl ExactSizeIterator<Item = &WordMapEntry> + use<'_> {
self.get_case_folded(CaseFoldedWordId::from_word_chars(word).0)
}
pub fn get_metadata_mut_canonical(
&mut self,
id: CanonicalWordId,
) -> Option<&mut DictWordMetadata> {
self.canonical.get_mut(&id).map(|v| &mut v.metadata)
}
pub fn insert(&mut self, entry: WordMapEntry) {
let (canonical_id, case_folded_id) =
(entry.word_ids.canonical(), entry.word_ids.case_folded());
if let Some(existing_entry) = self.canonical.get_mut(&canonical_id) {
existing_entry.metadata.merge(&entry.metadata);
} else {
let (canonical_idx, _) = self.canonical.insert_full(canonical_id, entry);
if let Some(existing_case_folded_entry) = self.case_folded.get_mut(&case_folded_id) {
if !existing_case_folded_entry.contains(&canonical_idx) {
existing_case_folded_entry.push(canonical_idx);
}
} else {
self.case_folded.insert(case_folded_id, vec![canonical_idx]);
}
}
}
pub fn reserve(&mut self, additional: usize) {
self.canonical.reserve(additional);
}
pub fn iter(&self) -> impl ExactSizeIterator<Item = &WordMapEntry> {
self.canonical.values()
}
pub fn len(&self) -> usize {
self.canonical.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn with_capacity(capacity: usize) -> Self {
Self {
canonical: IndexMap::with_capacity_and_hasher(capacity, DefaultHashBuilder::default()),
case_folded: HashMap::new(),
}
}
pub fn from_rune_files(word_list: &str, attr_list: &str) -> Result<Self, rune::Error> {
let word_list = parse_word_list(word_list)?;
let attr_list = AttributeList::parse(attr_list)?;
let mut word_map = WordMap::default();
attr_list.expand_annotated_words(word_list, &mut word_map);
Ok(word_map)
}
fn get_canonical_indices_from_case_folded(&self, id: CaseFoldedWordId) -> &[usize] {
self.case_folded
.get(&id)
.map_or(&[], |canonical_indices| canonical_indices)
}
}
impl WordMap {
pub fn append_word(&mut self, word: impl AsRef<[char]>, metadata: DictWordMetadata) {
self.insert(WordMapEntry::new(word.as_ref()).with_md(metadata));
}
pub fn append_word_str(&mut self, word: &str, metadata: DictWordMetadata) {
self.insert(WordMapEntry::new_str(word).with_md(metadata));
}
pub fn extend_words(
&mut self,
words: impl IntoIterator<Item = (impl AsRef<[char]>, DictWordMetadata)>,
) {
self.extend(words.into_iter().map(|(canonical_spelling, metadata)| {
WordMapEntry::new(canonical_spelling.as_ref()).with_md(metadata)
}))
}
}
impl Extend<WordMapEntry> for WordMap {
fn extend<T: IntoIterator<Item = WordMapEntry>>(&mut self, iter: T) {
let iter = iter.into_iter();
let reserve = if self.is_empty() {
iter.size_hint().0
} else {
iter.size_hint().0.div_ceil(2)
};
self.reserve(reserve);
iter.for_each(move |wme| {
self.insert(wme);
});
}
}
impl Index<usize> for WordMap {
type Output = <CanonicalStorage as Index<usize>>::Output;
fn index(&self, index: usize) -> &Self::Output {
&self.canonical[index]
}
}
impl IntoIterator for WordMap {
type Item = WordMapEntry;
type IntoIter = indexmap::map::IntoValues<CanonicalWordId, WordMapEntry>;
fn into_iter(self) -> Self::IntoIter {
self.canonical.into_values()
}
}
impl FromIterator<WordMapEntry> for WordMap {
fn from_iter<T: IntoIterator<Item = WordMapEntry>>(iter: T) -> Self {
let mut out = Self::new();
out.extend(iter);
out
}
}