DB Refactor

bffhd/utils/l10nstring.rs

@@ -0,0 +1,61 @@
+use std::collections::HashMap;
+use capnp::capability::Promise;
+use capnp::Error;
+use capnp_rpc::pry;
+use once_cell::sync::Lazy;
+use api::utils::l10n_string as l10n;
+
+struct Locales {
+    map: HashMap<&'static str, HashMap<&'static str, &'static str>>
+}
+
+impl Locales {
+    pub fn get(&self, lang: &str, msg: &str)
+        -> Option<(&'static str, &'static str)>
+    {
+        self.map.get(msg).and_then(|map| {
+            map.get_key_value(lang).map(|(k,v)| (*k, *v))
+        })
+    }
+
+    pub fn available(&self, _msg: &str) -> &[&'static str] {
+        &[]
+    }
+}
+
+static LANG: Lazy<Locales> = Lazy::new(|| {
+    Locales { map: HashMap::new() }
+});
+
+struct L10NString {
+    msg: &'static str,
+}
+
+impl l10n::Server for L10NString {
+    fn get(&mut self, params: l10n::GetParams, mut results: l10n::GetResults)
+        -> Promise<(), Error>
+    {
+        let lang = pry!(pry!(params.get()).get_lang());
+
+        if let Some((lang, content)) = LANG.get(lang, &self.msg) {
+            let mut builder = results.get();
+            builder.set_lang(lang);
+            builder.set_content(content);
+        }
+
+        Promise::ok(())
+    }
+
+    fn available(&mut self, _: l10n::AvailableParams, mut results: l10n::AvailableResults)
+        -> Promise<(), Error>
+    {
+        let langs = LANG.available(self.msg);
+        let builder = results.get();
+        let mut lb = builder.init_langs(langs.len() as u32);
+        for (n, lang) in langs.into_iter().enumerate() {
+            lb.reborrow().set(n as u32, *lang);
+        }
+
+        Promise::ok(())
+    }
+}

bffhd/utils/mod.rs

@@ -2,4 +2,9 @@
 pub mod oid;
 
 /// Variable sized integer types
-pub mod varint;
+pub mod varint;
+
+/// Localization strings
+pub mod l10nstring;
+
+pub mod uuid;

bffhd/utils/uuid.rs

@@ -0,0 +1,20 @@
+use uuid::Uuid;
+use api::utils::uuid::{Builder, Reader};
+
+pub fn uuid_to_api(uuid: Uuid, mut builder: Builder) {
+    let [a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p]
+        = uuid.as_u128().to_ne_bytes();
+    let lower = u64::from_ne_bytes([a,b,c,d,e,f,g,h]);
+    let upper = u64::from_ne_bytes([i,j,k,l,m,n,o,p]);
+    builder.set_lower(lower);
+    builder.set_upper(upper);
+}
+
+pub fn api_to_uuid(reader: Reader) -> Uuid {
+    let lower: u64 = reader.reborrow().get_lower();
+    let upper: u64 = reader.get_upper();
+    let [a,b,c,d,e,f,g,h] = lower.to_ne_bytes();
+    let [i,j,k,l,m,n,o,p] = upper.to_ne_bytes();
+    let num = u128::from_ne_bytes([a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p]);
+    Uuid::from_u128(num)
+}