translation-rs 0.4.1

Safe Rust bindings for Translation.framework — language availability, session workflows, and language recognition on macOS
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::{Deserialize, Serialize};

use crate::language::Language;
use crate::language_pair::LanguagePair;
use crate::translation_session::TranslationStrategy;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
/// Tracks mutable source and target languages for Translation.framework workflows.
pub struct TranslationConfiguration {
    source: Option<Language>,
    target: Option<Language>,
    #[serde(default)]
    preferred_strategy: TranslationStrategy,
    #[serde(default)]
    version: u64,
}

impl TranslationConfiguration {
    #[must_use]
    /// Creates an empty translation configuration.
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    /// Creates a configuration from a `LanguagePair`.
    pub fn from_language_pair(pair: impl Into<LanguagePair>) -> Self {
        let pair = pair.into();
        Self {
            source: Some(pair.source().clone()),
            target: pair.target().cloned(),
            preferred_strategy: TranslationStrategy::default(),
            version: 0,
        }
    }

    #[must_use]
    /// Returns the configured source language.
    pub fn source(&self) -> Option<&Language> {
        self.source.as_ref()
    }

    #[must_use]
    /// Returns the configured target language.
    pub fn target(&self) -> Option<&Language> {
        self.target.as_ref()
    }

    #[must_use]
    /// Returns the configured source language identifier.
    pub fn source_identifier(&self) -> Option<&str> {
        self.source().map(Language::identifier)
    }

    #[must_use]
    /// Returns the configured target language identifier.
    pub fn target_identifier(&self) -> Option<&str> {
        self.target().map(Language::identifier)
    }

    #[must_use]
    /// Returns the preferred Translation.framework strategy.
    pub const fn preferred_strategy(&self) -> TranslationStrategy {
        self.preferred_strategy
    }

    #[must_use]
    /// Returns the invalidation version tracked for this configuration.
    pub const fn version(&self) -> u64 {
        self.version
    }

    /// Sets the source language.
    pub fn set_source(&mut self, source: Option<Language>) {
        self.source = source;
    }

    /// Sets the target language.
    pub fn set_target(&mut self, target: Option<Language>) {
        self.target = target;
    }

    /// Sets the preferred Translation.framework strategy.
    pub fn set_preferred_strategy(&mut self, preferred_strategy: TranslationStrategy) {
        self.preferred_strategy = preferred_strategy;
    }

    /// Clears the source language.
    pub fn clear_source(&mut self) {
        self.source = None;
    }

    /// Clears the target language.
    pub fn clear_target(&mut self) {
        self.target = None;
    }

    /// Increments the invalidation version used by Translation updates.
    pub fn invalidate(&mut self) {
        self.version = self.version.saturating_add(1);
    }

    #[must_use]
    /// Returns a copy with the given source language.
    pub fn with_source(mut self, source: impl Into<Language>) -> Self {
        self.set_source(Some(source.into()));
        self
    }

    #[must_use]
    /// Returns a copy with the given target language.
    pub fn with_target(mut self, target: impl Into<Language>) -> Self {
        self.set_target(Some(target.into()));
        self
    }

    #[must_use]
    /// Returns a copy with the given preferred strategy.
    pub fn with_preferred_strategy(mut self, preferred_strategy: TranslationStrategy) -> Self {
        self.set_preferred_strategy(preferred_strategy);
        self
    }

    #[must_use]
    /// Returns a copy with no source language.
    pub fn without_source(mut self) -> Self {
        self.clear_source();
        self
    }

    #[must_use]
    /// Returns a copy with no target language.
    pub fn without_target(mut self) -> Self {
        self.clear_target();
        self
    }

    #[must_use]
    /// Returns the configured language pair when a source language exists.
    pub fn language_pair(&self) -> Option<LanguagePair> {
        self.source
            .clone()
            .map(|source| LanguagePair::new(source, self.target.clone()))
    }
}