From 74672f08073852a71221b81efeefb9dcd5330508 Mon Sep 17 00:00:00 2001
From: Manos Pitsidianakis <el13635@mail.ntua.gr>
Date: Thu, 7 Nov 2019 22:35:30 +0200
Subject: [PATCH] ui: Add CacheType option in configuration

CacheType's value dictates which cache backend to use: none, or sqlite3
---
 ui/src/conf.rs    | 47 ++++++++++++++++++++++++++++++++++++++++-------
 ui/src/sqlite3.rs |  2 +-
 2 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/ui/src/conf.rs b/ui/src/conf.rs
index 79a7d9f8..5cde9eeb 100644
--- a/ui/src/conf.rs
+++ b/ui/src/conf.rs
@@ -166,6 +166,8 @@ pub struct FileAccount {
     read_only: bool,
     subscribed_folders: Vec<String>,
     folders: Option<HashMap<String, FolderConf>>,
+    #[serde(default)]
+    cache_type: CacheType,
 }
 
 impl From<FileAccount> for AccountConf {
@@ -268,6 +270,10 @@ impl FileAccount {
     pub fn index_style(&self) -> IndexStyle {
         self.index_style
     }
+
+    pub fn cache_type(&self) -> &CacheType {
+        &self.cache_type
+    }
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -554,23 +560,50 @@ impl Serialize for IndexStyle {
     }
 }
 
-#[derive(Debug)]
-pub enum IndexCache {
-    Nothing,
+#[derive(Debug, Clone, PartialEq)]
+pub enum CacheType {
+    None,
     #[cfg(feature = "sqlite3")]
     Sqlite3,
-    Backend,
 }
 
-impl Default for IndexCache {
+impl Default for CacheType {
     fn default() -> Self {
         #[cfg(feature = "sqlite3")]
         {
-            IndexCache::Sqlite3
+            CacheType::Sqlite3
         }
         #[cfg(not(feature = "sqlite3"))]
         {
-            IndexCache::Nothing
+            CacheType::None
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for CacheType {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <String>::deserialize(deserializer)?;
+        match s.as_str() {
+            #[cfg(feature = "sqlite3")]
+            "sqlite3" => Ok(CacheType::Sqlite3),
+            "nothing" | "none" | "" => Ok(CacheType::None),
+            _ => Err(de::Error::custom("invalid `index_cache` value")),
+        }
+    }
+}
+
+impl Serialize for CacheType {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            #[cfg(feature = "sqlite3")]
+            CacheType::Sqlite3 => serializer.serialize_str("sqlite3"),
+            CacheType::None => serializer.serialize_str("none"),
         }
     }
 }
diff --git a/ui/src/sqlite3.rs b/ui/src/sqlite3.rs
index 87200868..67c9332a 100644
--- a/ui/src/sqlite3.rs
+++ b/ui/src/sqlite3.rs
@@ -198,7 +198,7 @@ pub fn index(context: &mut crate::state::Context) -> Result<()> {
     let mutexes = context
         .accounts
         .iter()
-        .filter(|acc| acc.settings.account().format() != "imap")
+        .filter(|acc| *acc.settings.conf.cache_type() == crate::conf::CacheType::Sqlite3)
         .map(|acc| (acc.collection.envelopes.clone(), acc.backend.clone()))
         .collect::<Vec<(Arc<RwLock<_>>, Arc<_>)>>();
     let env_hashes = mutexes