odict 3.3.0

A blazingly-fast dictionary file format for human languages
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[cfg(feature = "config")]
use std::ffi::OsStr;

use std::marker::PhantomData;
#[cfg(feature = "config")]
use std::path::PathBuf;

#[cfg(feature = "alias")]
use crate::alias::AliasManager;

use crate::OpenDictionary;

#[cfg(feature = "config")]
use crate::config::DEFAULT_CONFIG_DIR;

#[cfg(feature = "http")]
use crate::download::DictionaryDownloader;

#[derive(Clone)]
pub struct LoadOptions<'a> {
    #[cfg(feature = "alias")]
    alias_manager: crate::alias::AliasManager,
    #[cfg(feature = "http")]
    downloader: crate::download::DictionaryDownloader<'a>,
    #[cfg(feature = "config")]
    config_dir: PathBuf,
    phantom: PhantomData<&'a ()>,
}

impl<'a> Default for LoadOptions<'a> {
    fn default() -> Self {
        LoadOptions {
            #[cfg(feature = "config")]
            config_dir: DEFAULT_CONFIG_DIR.to_path_buf(),
            #[cfg(feature = "alias")]
            alias_manager: crate::alias::AliasManager::default(),
            #[cfg(feature = "http")]
            downloader: crate::download::DictionaryDownloader::default(),
            phantom: PhantomData,
        }
    }
}

impl<'a> LoadOptions<'a> {
    #[cfg(feature = "alias")]
    pub fn with_alias_manager(mut self, manager: AliasManager) -> Self {
        self.alias_manager = manager;
        self
    }

    #[cfg(feature = "config")]
    pub fn with_config_dir<D: AsRef<OsStr> + ?Sized>(mut self, dir: &D) -> Self {
        self.config_dir = PathBuf::from(dir);

        #[cfg(feature = "alias")]
        if self.alias_manager.config_dir.is_none() {
            self.alias_manager.config_dir = Some(self.config_dir.clone());
        }

        #[cfg(feature = "http")]
        if self.downloader.options.config_dir.is_none() {
            self.downloader.options.config_dir = Some(self.config_dir.clone());
        }

        self
    }

    #[cfg(feature = "http")]
    pub fn with_downloader(mut self, downloader: DictionaryDownloader<'a>) -> Self {
        self.downloader = downloader;
        self
    }
}

impl OpenDictionary {
    pub async fn load_with_options<'a>(
        name: &str,
        #[allow(unused_variables)] options: LoadOptions<'a>,
    ) -> crate::Result<OpenDictionary> {
        #[cfg(feature = "http")]
        match OpenDictionary::from_remote_with_downloader(name, options.downloader).await {
            Ok(dictionary) => {
                return Ok(dictionary);
            }
            // If the name is invalid, skip
            Err(crate::Error::InvalidDictionaryName(_)) => {}
            Err(e) => {
                return Err(e);
            }
        }

        #[cfg(feature = "alias")]
        match OpenDictionary::from_alias_with_manager(name, options.alias_manager) {
            Ok(dictionary) => {
                return Ok(dictionary);
            }
            // If no alias found, skip
            Err(crate::Error::AliasNotFound(_)) => {}
            Err(e) => {
                return Err(e);
            }
        }

        OpenDictionary::from_path(name)
    }

    pub async fn load(name: &str) -> crate::Result<OpenDictionary> {
        Self::load_with_options(name, LoadOptions::default()).await
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::LoadOptions;

    #[test]
    fn test_config_set() {
        let path = PathBuf::from("some/config/dir");
        let options = LoadOptions::default().with_config_dir(&path);

        assert_eq!(options.downloader.options.config_dir, Some(path.clone()));
        assert_eq!(options.alias_manager.config_dir, Some(path.clone()));
    }
}