From 0f18be24b51ea3c74879ede2d7ab0546b7e01571 Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Tue, 28 Mar 2023 10:58:26 +0200
Subject: [PATCH 1/8] encode database labels using URL encoding

---
 Cargo.toml               |  1 +
 src/storage/directory.rs | 33 +++++++++++++++++++++++++++------
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ad03b3b2..2dc7f811 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,6 +34,7 @@ base64 = "0.13"
 hex = "0.4"
 regex = "1.5"
 lru = "0.10"
+urlencoding = "2.1.2"
 
 [dev-dependencies]
 tempfile = "3.1"
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 54702adc..50c1f200 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -9,6 +9,7 @@ use std::sync::Arc;
 use tokio::fs::{self, *};
 use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
 use tokio::sync::RwLock;
+use urlencoding::{encode,decode};
 
 use async_trait::async_trait;
 
@@ -219,6 +220,8 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
         ));
     }
 
+    let name = decode(name.as_str()).unwrap().to_string();
+
     if layer_str.is_empty() {
         Ok(Label {
             name,
@@ -288,7 +291,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn create_label(&self, label: &str) -> io::Result<Label> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label));
+        p.push(encode(format!("{}.label", label).as_str()).to_string());
         let contents = "0\n\n".to_string().into_bytes();
         match fs::metadata(&p).await {
             Ok(_) => Err(io::Error::new(
@@ -311,7 +314,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn get_label(&self, label: &str) -> io::Result<Option<Label>> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label));
+        p.push(encode(format!("{}.label", label).as_str()).to_string());
 
         match get_label_from_file(p).await {
             Ok(label) => Ok(Some(label)),
@@ -336,7 +339,7 @@ impl LabelStore for DirectoryLabelStore {
         };
 
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label.name));
+        p.push(encode(format!("{}.label", label.name).as_str()).to_string());
         let (retrieved_label, mut file) = get_label_from_exclusive_locked_file(p).await?;
         if retrieved_label == *label {
             // all good, let's a go
@@ -352,7 +355,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn delete_label(&self, name: &str) -> io::Result<bool> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", name));
+        p.push(encode(format!("{}.label", name).as_str()).to_string());
 
         // We're not locking here to remove the file. The assumption
         // is that any concurrent operation that is done on the label
@@ -490,7 +493,7 @@ impl LabelStore for CachedDirectoryLabelStore {
             if retrieved_label == label {
                 // all good, let's a go
                 let mut p = self.path.clone();
-                p.push(format!("{}.label", label.name));
+                p.push(encode(format!("{}.label", label.name).as_str()).to_string());
                 let mut options = fs::OpenOptions::new();
                 options.create(false);
                 options.write(true);
@@ -513,7 +516,7 @@ impl LabelStore for CachedDirectoryLabelStore {
         let mut labels = self.labels.write().await;
         if labels.remove(name).is_some() {
             let mut p = self.path.clone();
-            p.push(format!("{}.label", name));
+            p.push(encode(format!("{}.label", name).as_str()).to_string());
             tokio::fs::remove_file(p).await?;
 
             Ok(true)
@@ -638,6 +641,24 @@ mod tests {
         assert_eq!(stored, retrieved.unwrap());
     }
 
+    #[tokio::test]
+    async fn directory_create_and_retrieve_equal_url_label() {
+        let dir = tempdir().unwrap();
+        let store = DirectoryLabelStore::new(dir.path());
+
+        let (stored, retrieved) = async {
+            let stored = store.create_label("https://terminusdb.com/?s=does+work").await?;
+            let retrieved = store.get_label("https://terminusdb.com/?s=does+work").await?;
+
+            Ok::<_, io::Error>((stored, retrieved))
+        }
+        .await
+        .unwrap();
+
+        assert_eq!(None, stored.layer);
+        assert_eq!(stored, retrieved.unwrap());
+    }
+
     #[tokio::test]
     async fn directory_update_label_succeeds() {
         let dir = tempdir().unwrap();

From 86c7150017bc4901b36b891e00269dc09cf2e0ae Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Tue, 28 Mar 2023 11:09:56 +0200
Subject: [PATCH 2/8] fixed code formatting

---
 src/storage/directory.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 50c1f200..48b079aa 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 use tokio::fs::{self, *};
 use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
 use tokio::sync::RwLock;
-use urlencoding::{encode,decode};
+use urlencoding::{decode, encode};
 
 use async_trait::async_trait;
 
@@ -647,8 +647,12 @@ mod tests {
         let store = DirectoryLabelStore::new(dir.path());
 
         let (stored, retrieved) = async {
-            let stored = store.create_label("https://terminusdb.com/?s=does+work").await?;
-            let retrieved = store.get_label("https://terminusdb.com/?s=does+work").await?;
+            let stored = store
+                .create_label("https://terminusdb.com/?s=does+work")
+                .await?;
+            let retrieved = store
+                .get_label("https://terminusdb.com/?s=does+work")
+                .await?;
 
             Ok::<_, io::Error>((stored, retrieved))
         }

From fb71d9887d21ccc9e0084cbf87abeb3841b3496b Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Thu, 30 Mar 2023 15:14:59 +0200
Subject: [PATCH 3/8] made label file name encoding configurable and extendable

---
 Cargo.toml                 |   1 +
 benches/bench.rs           |   3 +-
 benches/builder/main.rs    |  11 +--
 examples/create_graph.rs   |   3 +-
 examples/print_graph.rs    |   3 +-
 examples/write_to_graph.rs |   3 +-
 src/storage/directory.rs   | 138 +++++++++++++++++++++++--------------
 src/store/mod.rs           |  44 +++++++-----
 src/store/sync.rs          |  25 +++++--
 9 files changed, 147 insertions(+), 84 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2dc7f811..113e9a03 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,6 +35,7 @@ hex = "0.4"
 regex = "1.5"
 lru = "0.10"
 urlencoding = "2.1.2"
+dyn-clone = "1.0.11"
 
 [dev-dependencies]
 tempfile = "3.1"
diff --git a/benches/bench.rs b/benches/bench.rs
index e5522071..8b92d962 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -4,12 +4,13 @@ extern crate test;
 use tempfile::tempdir;
 use terminus_store;
 use terminus_store::layer::ValueTriple;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use test::Bencher;
 
 #[bench]
 fn bench_add_string_triple(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let sync_store = terminus_store::open_sync_directory_store(dir.path());
+    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
     let layer_builder = sync_store.create_base_layer().unwrap();
     let mut count = 1;
     b.iter(|| {
diff --git a/benches/builder/main.rs b/benches/builder/main.rs
index 9557c93b..757067ce 100644
--- a/benches/builder/main.rs
+++ b/benches/builder/main.rs
@@ -5,6 +5,7 @@ mod data;
 use rand::prelude::*;
 use tempfile::tempdir;
 use terminus_store;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use test::Bencher;
 
 use data::*;
@@ -12,7 +13,7 @@ use data::*;
 #[bench]
 fn build_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
 
     b.iter(|| {
         let builder = store.create_base_layer().unwrap();
@@ -23,7 +24,7 @@ fn build_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_base_layer_1000(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
@@ -48,7 +49,7 @@ fn build_base_layer_1000(b: &mut Bencher) {
 #[bench]
 fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -61,7 +62,7 @@ fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -88,7 +89,7 @@ fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_nonempty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
diff --git a/examples/create_graph.rs b/examples/create_graph.rs
index fba7644f..50abaf74 100644
--- a/examples/create_graph.rs
+++ b/examples/create_graph.rs
@@ -1,6 +1,7 @@
 use std::env;
 
 use terminus_store::*;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use tokio;
 
 #[tokio::main]
@@ -10,7 +11,7 @@ async fn main() {
         println!("usage: {} <path> <graph_name>", args[0]);
     } else {
         // open a store at the given path. the directory has to exist.
-        let store = open_directory_store(&args[1]);
+        let store = open_directory_store(&args[1], NoFilenameEncoding{});
 
         // then create a graph. if the graph already exists, this will error.
         store.create(&args[2]).await.unwrap();
diff --git a/examples/print_graph.rs b/examples/print_graph.rs
index 85513e91..6b929102 100644
--- a/examples/print_graph.rs
+++ b/examples/print_graph.rs
@@ -1,12 +1,13 @@
 use std::env;
 
 use std::io;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use terminus_store::structure::TdbDataType;
 use terminus_store::*;
 use tokio;
 
 async fn print_graph(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path);
+    let store = open_directory_store(store_path, NoFilenameEncoding{});
     let graph = store
         .open(graph)
         .await?
diff --git a/examples/write_to_graph.rs b/examples/write_to_graph.rs
index 5a67ceb6..9f18850a 100644
--- a/examples/write_to_graph.rs
+++ b/examples/write_to_graph.rs
@@ -3,6 +3,7 @@ use std::env;
 use lazy_static::lazy_static;
 use regex::Regex;
 use terminus_store::*;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use tokio;
 use tokio::io::{self, AsyncBufReadExt};
 
@@ -52,7 +53,7 @@ async fn parse_command(s: &str) -> io::Result<Command> {
 }
 
 async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path);
+    let store = open_directory_store(store_path, NoFilenameEncoding{});
     let graph = store
         .open(graph)
         .await?
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 48b079aa..f13507b1 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -9,6 +9,7 @@ use std::sync::Arc;
 use tokio::fs::{self, *};
 use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
 use tokio::sync::RwLock;
+use dyn_clone::{clone_trait_object, DynClone};
 use urlencoding::{decode, encode};
 
 use async_trait::async_trait;
@@ -182,14 +183,46 @@ impl PersistentLayerStore for DirectoryLayerStore {
     }
 }
 
+pub trait FilenameEncoding : DynClone + Send + Sync {
+    fn encode(&self, str: String) -> String;
+    fn decode(&self, str: String) -> String;
+}
+
+clone_trait_object!(FilenameEncoding);
+
+#[derive(Clone)]
+pub struct NoFilenameEncoding {}
+
+impl FilenameEncoding for NoFilenameEncoding {
+    fn encode(&self, str: String) -> String {
+        str
+    }
+    fn decode(&self, str: String) -> String {
+        str
+    }
+}
+
+#[derive(Clone)]
+pub struct URLFilenameEncoding {}
+
+impl FilenameEncoding for URLFilenameEncoding {
+    fn encode(&self, str: String) -> String {
+        return encode(str.as_str()).to_string();
+    }
+    fn decode(&self, str: String) -> String {
+        return decode(str.as_str()).unwrap().to_string();
+    }
+}
+
 #[derive(Clone)]
 pub struct DirectoryLabelStore {
     path: PathBuf,
+    filename_encoding: Box<dyn FilenameEncoding>,
 }
 
 impl DirectoryLabelStore {
-    pub fn new<P: Into<PathBuf>>(path: P) -> DirectoryLabelStore {
-        DirectoryLabelStore { path: path.into() }
+    pub fn new<P: Into<PathBuf>>(path: P, encoding: impl FilenameEncoding + 'static) -> DirectoryLabelStore {
+        DirectoryLabelStore { path: path.into(), filename_encoding: Box::new(encoding) }
     }
 }
 
@@ -220,8 +253,6 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
         ));
     }
 
-    let name = decode(name.as_str()).unwrap().to_string();
-
     if layer_str.is_empty() {
         Ok(Label {
             name,
@@ -238,28 +269,30 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
     }
 }
 
-async fn get_label_from_file<P: Into<PathBuf>>(path: P) -> io::Result<Label> {
+async fn get_label_from_file<P: Into<PathBuf>>(
+    path: P,
+    name: String
+) -> io::Result<Label> {
     let path: PathBuf = path.into();
-    let label = path.file_stem().unwrap().to_str().unwrap().to_owned();
 
     let mut file = LockedFile::open(path).await?;
     let mut data = Vec::new();
     file.read_to_end(&mut data).await?;
 
-    get_label_from_data(label, &data)
+    get_label_from_data(name, &data)
 }
 
 async fn get_label_from_exclusive_locked_file<P: Into<PathBuf>>(
     path: P,
+    name: String
 ) -> io::Result<(Label, ExclusiveLockedFile)> {
     let path: PathBuf = path.into();
-    let label = path.file_stem().unwrap().to_str().unwrap().to_owned();
 
     let mut file = ExclusiveLockedFile::open(path).await?;
     let mut data = Vec::new();
     file.read_to_end(&mut data).await?;
 
-    let label = get_label_from_data(label, &data)?;
+    let label = get_label_from_data(name, &data)?;
     file.seek(SeekFrom::Start(0)).await?;
 
     Ok((label, file))
@@ -280,7 +313,14 @@ impl LabelStore for DirectoryLabelStore {
                     )
                 })?;
                 if name.ends_with(".label") {
-                    let label = get_label_from_file(direntry.path()).await?;
+                    let label = get_label_from_file(
+                        direntry.path(),
+                        self.filename_encoding.decode(
+                            direntry.path().file_stem()
+                            .unwrap().to_str()
+                            .unwrap().to_owned()
+                        )
+                    ).await?;
                     result.push(label);
                 }
             }
@@ -291,7 +331,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn create_label(&self, label: &str) -> io::Result<Label> {
         let mut p = self.path.clone();
-        p.push(encode(format!("{}.label", label).as_str()).to_string());
+        p.push(self.filename_encoding.encode(format!("{}.label", label)));
         let contents = "0\n\n".to_string().into_bytes();
         match fs::metadata(&p).await {
             Ok(_) => Err(io::Error::new(
@@ -314,9 +354,9 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn get_label(&self, label: &str) -> io::Result<Option<Label>> {
         let mut p = self.path.clone();
-        p.push(encode(format!("{}.label", label).as_str()).to_string());
+        p.push(self.filename_encoding.encode(format!("{}.label", label)));
 
-        match get_label_from_file(p).await {
+        match get_label_from_file(p, label.to_owned()).await {
             Ok(label) => Ok(Some(label)),
             Err(e) => match e.kind() {
                 io::ErrorKind::NotFound => Ok(None),
@@ -339,8 +379,8 @@ impl LabelStore for DirectoryLabelStore {
         };
 
         let mut p = self.path.clone();
-        p.push(encode(format!("{}.label", label.name).as_str()).to_string());
-        let (retrieved_label, mut file) = get_label_from_exclusive_locked_file(p).await?;
+        p.push(self.filename_encoding.encode(format!("{}.label", label.name)));
+        let (retrieved_label, mut file) = get_label_from_exclusive_locked_file(p, label.name.clone()).await?;
         if retrieved_label == *label {
             // all good, let's a go
             file.truncate().await?;
@@ -355,7 +395,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn delete_label(&self, name: &str) -> io::Result<bool> {
         let mut p = self.path.clone();
-        p.push(encode(format!("{}.label", name).as_str()).to_string());
+        p.push(self.filename_encoding.encode(format!("{}.label", name)));
 
         // We're not locking here to remove the file. The assumption
         // is that any concurrent operation that is done on the label
@@ -387,6 +427,7 @@ impl LabelStore for DirectoryLabelStore {
 pub struct CachedDirectoryLabelStore {
     path: PathBuf,
     labels: Arc<RwLock<HashMap<String, Label>>>,
+    encoding: Box<dyn FilenameEncoding>,
 }
 
 impl CachedDirectoryLabelStore {
@@ -394,38 +435,33 @@ impl CachedDirectoryLabelStore {
     ///
     /// This will read in all label files on startup, which is why
     /// this is an async operation.
-    pub async fn open<P: Into<PathBuf>>(path: P) -> io::Result<Self> {
+    pub async fn open<P: Into<PathBuf>>(path: P, encoding: impl FilenameEncoding + 'static) -> io::Result<Self> {
         let path: PathBuf = path.into();
-        let labels = get_all_labels_from_dir(&path).await?;
+        let mut labels = HashMap::new();
+        let mut entries = tokio::fs::read_dir(&path).await?;
 
-        Ok(Self {
-            path,
-            labels: Arc::new(RwLock::new(labels)),
-        })
-    }
-}
-
-async fn get_all_labels_from_dir(p: &PathBuf) -> io::Result<HashMap<String, Label>> {
-    let mut result = HashMap::new();
-    let mut entries = tokio::fs::read_dir(p).await?;
-
-    while let Some(entry) = entries.next_entry().await? {
-        if !entry.file_type().await?.is_file() {
-            continue;
-        }
-        if let Ok(file_name) = entry.file_name().into_string() {
-            if !file_name.ends_with(".label") {
+        while let Some(entry) = entries.next_entry().await? {
+            if !entry.file_type().await?.is_file() {
                 continue;
             }
+            if let Ok(file_name) = entry.file_name().into_string() {
+                if !file_name.ends_with(".label") {
+                    continue;
+                }
 
-            let label_name = file_name[..file_name.len() - 6].to_string();
-            let label = get_label_from_file(entry.path()).await?;
+                let label_name = file_name[..file_name.len() - 6].to_string();
+                let label = get_label_from_file(entry.path(), encoding.decode(label_name.clone())).await?;
 
-            result.insert(label_name, label);
+                labels.insert(label_name, label);
+            }
         }
-    }
 
-    Ok(result)
+        Ok(Self {
+            path,
+            labels: Arc::new(RwLock::new(labels)),
+            encoding: Box::new(encoding)
+        })
+    }
 }
 
 #[async_trait]
@@ -493,7 +529,7 @@ impl LabelStore for CachedDirectoryLabelStore {
             if retrieved_label == label {
                 // all good, let's a go
                 let mut p = self.path.clone();
-                p.push(encode(format!("{}.label", label.name).as_str()).to_string());
+                p.push(self.encoding.encode(format!("{}.label", label.name)));
                 let mut options = fs::OpenOptions::new();
                 options.create(false);
                 options.write(true);
@@ -516,7 +552,7 @@ impl LabelStore for CachedDirectoryLabelStore {
         let mut labels = self.labels.write().await;
         if labels.remove(name).is_some() {
             let mut p = self.path.clone();
-            p.push(encode(format!("{}.label", name).as_str()).to_string());
+            p.push(self.encoding.encode(format!("{}.label", name)));
             tokio::fs::remove_file(p).await?;
 
             Ok(true)
@@ -626,7 +662,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         let (stored, retrieved) = async {
             let stored = store.create_label("foo").await?;
@@ -644,7 +680,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_url_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding{});
 
         let (stored, retrieved) = async {
             let stored = store
@@ -666,7 +702,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_succeeds() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         let retrieved = async {
             let stored = store.create_label("foo").await?;
@@ -684,7 +720,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_twice_from_same_label_object_fails() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         let (stored2, stored3) = async {
             let stored1 = store.create_label("foo").await?;
@@ -704,7 +740,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_label_twice_errors() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         store.create_label("foo").await.unwrap();
         let result = store.create_label("foo").await;
@@ -824,7 +860,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_delete_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         store.create_label("foo").await.unwrap();
         assert!(store.get_label("foo").await.unwrap().is_some());
@@ -835,7 +871,7 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         assert!(!store.delete_label("foo").await.unwrap());
     }
@@ -843,7 +879,7 @@ mod tests {
     #[tokio::test]
     async fn delete_shared_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
@@ -855,7 +891,7 @@ mod tests {
     #[tokio::test]
     async fn delete_exclusive_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 3c776171..337de941 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -10,7 +10,7 @@ use crate::layer::{IdTriple, Layer, LayerBuilder, LayerCounts, ObjectType, Value
 use crate::storage::archive::{
     ArchiveLayerStore, DirectoryArchiveBackend, LruArchiveBackend, LruMetadataArchiveBackend,
 };
-use crate::storage::directory::{DirectoryLabelStore, DirectoryLayerStore};
+use crate::storage::directory::{DirectoryLabelStore, DirectoryLayerStore, FilenameEncoding};
 use crate::storage::memory::{MemoryLabelStore, MemoryLayerStore};
 use crate::storage::{CachedLayerStore, LabelStore, LayerStore, LockingHashMapLayerCache};
 use crate::structure::TypedDictEntry;
@@ -910,14 +910,18 @@ pub fn open_memory_store() -> Store {
 /// cache_size specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> Store {
+/// filename_encoding specifies encoding strategy implemented using
+/// FilenameEncoding trait that is used to generate label file names
+/// from database labels (NoFilenameEncoding does no encoding;
+/// URLFilenameEncoding uses URL encoding algorithm).
+pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize, filename_encoding: impl FilenameEncoding + 'static) -> Store {
     let p = path.into();
     let directory_archive_backend = DirectoryArchiveBackend::new(p.clone());
     let archive_backend = LruArchiveBackend::new(directory_archive_backend.clone(), cache_size);
     let archive_metadata_backend =
         LruMetadataArchiveBackend::new(directory_archive_backend, archive_backend.clone());
     Store::new(
-        DirectoryLabelStore::new(p),
+        DirectoryLabelStore::new(p, filename_encoding),
         CachedLayerStore::new(
             ArchiveLayerStore::new(archive_metadata_backend, archive_backend),
             LockingHashMapLayerCache::new(),
@@ -926,10 +930,15 @@ pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> Store
 }
 
 /// Open a store that stores its data in the given directory.
-pub fn open_directory_store<P: Into<PathBuf>>(path: P) -> Store {
+///
+/// filename_encoding specifies encoding strategy implemented using
+/// FilenameEncoding trait that is used to generate label file names
+/// from database labels (NoFilenameEncoding does no encoding;
+/// URLFilenameEncoding uses URL encoding algorithm).
+pub fn open_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: impl FilenameEncoding + 'static) -> Store {
     let p = path.into();
     Store::new(
-        DirectoryLabelStore::new(p.clone()),
+        DirectoryLabelStore::new(p.clone(), filename_encoding),
         CachedLayerStore::new(DirectoryLayerStore::new(p), LockingHashMapLayerCache::new()),
     )
 }
@@ -938,6 +947,7 @@ pub fn open_directory_store<P: Into<PathBuf>>(path: P) -> Store {
 mod tests {
     use super::*;
     use tempfile::tempdir;
+    use crate::storage::directory::NoFilenameEncoding;
 
     async fn create_and_manipulate_database(store: Store) {
         let database = store.create("foodb").await.unwrap();
@@ -979,7 +989,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_manipulate_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
 
         create_and_manipulate_database(store).await;
     }
@@ -1502,7 +1512,7 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
 
         cached_layer_name_does_not_change_after_rollup(store).await
     }
@@ -1548,14 +1558,14 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup_upto() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         cached_layer_name_does_not_change_after_rollup_upto(store).await
     }
 
     #[tokio::test]
     async fn force_update_with_matching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1570,7 +1580,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1585,7 +1595,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_matching_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1604,7 +1614,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatched_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1623,7 +1633,7 @@ mod tests {
     #[tokio::test]
     async fn delete_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let _ = store.create("foo").await.unwrap();
         assert!(store.delete("foo").await.unwrap());
         assert!(store.open("foo").await.unwrap().is_none());
@@ -1632,14 +1642,14 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         assert!(!store.delete("foo").await.unwrap());
     }
 
     #[tokio::test]
     async fn delete_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
         assert!(store.open("foo").await.unwrap().is_some());
         graph.delete().await.unwrap();
@@ -1649,7 +1659,7 @@ mod tests {
     #[tokio::test]
     async fn recreate_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         let graph = store.create("foo").await.unwrap();
         let builder = store.create_base_layer().await.unwrap();
         let layer = builder.commit().await.unwrap();
@@ -1663,7 +1673,7 @@ mod tests {
     #[tokio::test]
     async fn list_databases() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
         assert!(store.labels().await.unwrap().is_empty());
         let _ = store.create("foo").await.unwrap();
         let one = vec!["foo".to_string()];
diff --git a/src/store/sync.rs b/src/store/sync.rs
index 694012d5..7dcb52f0 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -12,6 +12,7 @@ use std::io;
 use std::path::PathBuf;
 
 use crate::layer::{IdTriple, Layer, LayerCounts, ObjectType, ValueTriple};
+use crate::storage::directory::FilenameEncoding;
 use crate::store::{
     open_directory_store, open_memory_store, NamedGraph, Store, StoreLayer, StoreLayerBuilder,
 };
@@ -598,8 +599,13 @@ pub fn open_sync_memory_store() -> SyncStore {
 }
 
 /// Open a store that stores its data in the given directory.
-pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P) -> SyncStore {
-    SyncStore::wrap(open_directory_store(path))
+///
+/// filename_encoding specifies encoding strategy implemented using
+/// FilenameEncoding trait that is used to generate label file names
+/// from database labels (NoFilenameEncoding does no encoding;
+/// URLFilenameEncoding uses URL encoding algorithm).
+pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: impl FilenameEncoding + 'static) -> SyncStore {
+    SyncStore::wrap(open_directory_store(path, filename_encoding))
 }
 
 /// Open a store that stores its data in the given directory as archive files.
@@ -607,14 +613,19 @@ pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P) -> SyncStore {
 /// cache_size specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-pub fn open_sync_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> SyncStore {
-    SyncStore::wrap(open_archive_store(path, cache_size))
+/// filename_encoding specifies encoding strategy implemented using
+/// FilenameEncoding trait that is used to generate label file names
+/// from database labels (NoFilenameEncoding does no encoding;
+/// URLFilenameEncoding uses URL encoding algorithm).
+pub fn open_sync_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize, filename_encoding: impl FilenameEncoding + 'static) -> SyncStore {
+    SyncStore::wrap(open_archive_store(path, cache_size, filename_encoding))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use tempfile::tempdir;
+    use crate::storage::directory::NoFilenameEncoding;
 
     #[test]
     fn create_and_manipulate_sync_memory_database() {
@@ -651,7 +662,7 @@ mod tests {
     #[test]
     fn create_and_manipulate_sync_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_sync_directory_store(dir.path());
+        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding{});
         let database = store.create("foodb").unwrap();
 
         let head = database.head().unwrap();
@@ -716,10 +727,10 @@ mod tests {
     #[test]
     fn export_and_import_pack() {
         let dir1 = tempdir().unwrap();
-        let store1 = open_sync_directory_store(dir1.path());
+        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding{});
 
         let dir2 = tempdir().unwrap();
-        let store2 = open_sync_directory_store(dir2.path());
+        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding{});
 
         let builder1 = store1.create_base_layer().unwrap();
         builder1

From 6a5abec4830872ee4b56dfdd8edd11cec4c93bf6 Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Thu, 30 Mar 2023 15:47:44 +0200
Subject: [PATCH 4/8] code formatting and minor adjustments

---
 benches/bench.rs           |  2 +-
 benches/builder/main.rs    | 10 ++---
 examples/create_graph.rs   |  4 +-
 examples/print_graph.rs    |  2 +-
 examples/write_to_graph.rs |  4 +-
 src/storage/directory.rs   | 78 +++++++++++++++++++++++---------------
 src/store/mod.rs           | 55 ++++++++++++++++-----------
 src/store/sync.rs          | 37 +++++++++++-------
 8 files changed, 113 insertions(+), 79 deletions(-)

diff --git a/benches/bench.rs b/benches/bench.rs
index 8b92d962..00881c73 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -10,7 +10,7 @@ use test::Bencher;
 #[bench]
 fn bench_add_string_triple(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
     let layer_builder = sync_store.create_base_layer().unwrap();
     let mut count = 1;
     b.iter(|| {
diff --git a/benches/builder/main.rs b/benches/builder/main.rs
index 757067ce..bf26f891 100644
--- a/benches/builder/main.rs
+++ b/benches/builder/main.rs
@@ -13,7 +13,7 @@ use data::*;
 #[bench]
 fn build_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
 
     b.iter(|| {
         let builder = store.create_base_layer().unwrap();
@@ -24,7 +24,7 @@ fn build_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_base_layer_1000(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
@@ -49,7 +49,7 @@ fn build_base_layer_1000(b: &mut Bencher) {
 #[bench]
 fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -62,7 +62,7 @@ fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -89,7 +89,7 @@ fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_nonempty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
diff --git a/examples/create_graph.rs b/examples/create_graph.rs
index 50abaf74..9d4d701d 100644
--- a/examples/create_graph.rs
+++ b/examples/create_graph.rs
@@ -1,7 +1,7 @@
 use std::env;
 
-use terminus_store::*;
 use terminus_store::storage::directory::NoFilenameEncoding;
+use terminus_store::*;
 use tokio;
 
 #[tokio::main]
@@ -11,7 +11,7 @@ async fn main() {
         println!("usage: {} <path> <graph_name>", args[0]);
     } else {
         // open a store at the given path. the directory has to exist.
-        let store = open_directory_store(&args[1], NoFilenameEncoding{});
+        let store = open_directory_store(&args[1], NoFilenameEncoding {});
 
         // then create a graph. if the graph already exists, this will error.
         store.create(&args[2]).await.unwrap();
diff --git a/examples/print_graph.rs b/examples/print_graph.rs
index 6b929102..66815976 100644
--- a/examples/print_graph.rs
+++ b/examples/print_graph.rs
@@ -7,7 +7,7 @@ use terminus_store::*;
 use tokio;
 
 async fn print_graph(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path, NoFilenameEncoding{});
+    let store = open_directory_store(store_path, NoFilenameEncoding {});
     let graph = store
         .open(graph)
         .await?
diff --git a/examples/write_to_graph.rs b/examples/write_to_graph.rs
index 9f18850a..d188c4f0 100644
--- a/examples/write_to_graph.rs
+++ b/examples/write_to_graph.rs
@@ -2,8 +2,8 @@ use std::env;
 
 use lazy_static::lazy_static;
 use regex::Regex;
-use terminus_store::*;
 use terminus_store::storage::directory::NoFilenameEncoding;
+use terminus_store::*;
 use tokio;
 use tokio::io::{self, AsyncBufReadExt};
 
@@ -53,7 +53,7 @@ async fn parse_command(s: &str) -> io::Result<Command> {
 }
 
 async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path, NoFilenameEncoding{});
+    let store = open_directory_store(store_path, NoFilenameEncoding {});
     let graph = store
         .open(graph)
         .await?
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index f13507b1..2ef6cc43 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -1,6 +1,7 @@
 //! Directory-based implementation of storage traits.
 
 use bytes::{Bytes, BytesMut};
+use dyn_clone::{clone_trait_object, DynClone};
 use locking::*;
 use std::collections::HashMap;
 use std::io::{self, SeekFrom};
@@ -9,7 +10,6 @@ use std::sync::Arc;
 use tokio::fs::{self, *};
 use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
 use tokio::sync::RwLock;
-use dyn_clone::{clone_trait_object, DynClone};
 use urlencoding::{decode, encode};
 
 use async_trait::async_trait;
@@ -183,7 +183,7 @@ impl PersistentLayerStore for DirectoryLayerStore {
     }
 }
 
-pub trait FilenameEncoding : DynClone + Send + Sync {
+pub trait FilenameEncoding: DynClone + Send + Sync {
     fn encode(&self, str: String) -> String;
     fn decode(&self, str: String) -> String;
 }
@@ -221,8 +221,14 @@ pub struct DirectoryLabelStore {
 }
 
 impl DirectoryLabelStore {
-    pub fn new<P: Into<PathBuf>>(path: P, encoding: impl FilenameEncoding + 'static) -> DirectoryLabelStore {
-        DirectoryLabelStore { path: path.into(), filename_encoding: Box::new(encoding) }
+    pub fn new<P: Into<PathBuf>>(
+        path: P,
+        filename_encoding: impl FilenameEncoding + 'static
+    ) -> DirectoryLabelStore {
+        DirectoryLabelStore {
+            path: path.into(),
+            filename_encoding: Box::new(filename_encoding),
+        }
     }
 }
 
@@ -269,10 +275,7 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
     }
 }
 
-async fn get_label_from_file<P: Into<PathBuf>>(
-    path: P,
-    name: String
-) -> io::Result<Label> {
+async fn get_label_from_file<P: Into<PathBuf>>(path: P, name: String) -> io::Result<Label> {
     let path: PathBuf = path.into();
 
     let mut file = LockedFile::open(path).await?;
@@ -284,7 +287,7 @@ async fn get_label_from_file<P: Into<PathBuf>>(
 
 async fn get_label_from_exclusive_locked_file<P: Into<PathBuf>>(
     path: P,
-    name: String
+    name: String,
 ) -> io::Result<(Label, ExclusiveLockedFile)> {
     let path: PathBuf = path.into();
 
@@ -316,11 +319,16 @@ impl LabelStore for DirectoryLabelStore {
                     let label = get_label_from_file(
                         direntry.path(),
                         self.filename_encoding.decode(
-                            direntry.path().file_stem()
-                            .unwrap().to_str()
-                            .unwrap().to_owned()
-                        )
-                    ).await?;
+                            direntry
+                                .path()
+                                .file_stem()
+                                .unwrap()
+                                .to_str()
+                                .unwrap()
+                                .to_owned(),
+                        ),
+                    )
+                    .await?;
                     result.push(label);
                 }
             }
@@ -379,8 +387,12 @@ impl LabelStore for DirectoryLabelStore {
         };
 
         let mut p = self.path.clone();
-        p.push(self.filename_encoding.encode(format!("{}.label", label.name)));
-        let (retrieved_label, mut file) = get_label_from_exclusive_locked_file(p, label.name.clone()).await?;
+        p.push(
+            self.filename_encoding
+                .encode(format!("{}.label", label.name)),
+        );
+        let (retrieved_label, mut file) =
+            get_label_from_exclusive_locked_file(p, label.name.clone()).await?;
         if retrieved_label == *label {
             // all good, let's a go
             file.truncate().await?;
@@ -427,7 +439,7 @@ impl LabelStore for DirectoryLabelStore {
 pub struct CachedDirectoryLabelStore {
     path: PathBuf,
     labels: Arc<RwLock<HashMap<String, Label>>>,
-    encoding: Box<dyn FilenameEncoding>,
+    filename_encoding: Box<dyn FilenameEncoding>,
 }
 
 impl CachedDirectoryLabelStore {
@@ -435,7 +447,10 @@ impl CachedDirectoryLabelStore {
     ///
     /// This will read in all label files on startup, which is why
     /// this is an async operation.
-    pub async fn open<P: Into<PathBuf>>(path: P, encoding: impl FilenameEncoding + 'static) -> io::Result<Self> {
+    pub async fn open<P: Into<PathBuf>>(
+        path: P,
+        filename_encoding: impl FilenameEncoding + 'static
+    ) -> io::Result<Self> {
         let path: PathBuf = path.into();
         let mut labels = HashMap::new();
         let mut entries = tokio::fs::read_dir(&path).await?;
@@ -450,7 +465,8 @@ impl CachedDirectoryLabelStore {
                 }
 
                 let label_name = file_name[..file_name.len() - 6].to_string();
-                let label = get_label_from_file(entry.path(), encoding.decode(label_name.clone())).await?;
+                let label =
+                    get_label_from_file(entry.path(), filename_encoding.decode(label_name.clone())).await?;
 
                 labels.insert(label_name, label);
             }
@@ -459,7 +475,7 @@ impl CachedDirectoryLabelStore {
         Ok(Self {
             path,
             labels: Arc::new(RwLock::new(labels)),
-            encoding: Box::new(encoding)
+            filename_encoding: Box::new(filename_encoding),
         })
     }
 }
@@ -529,7 +545,7 @@ impl LabelStore for CachedDirectoryLabelStore {
             if retrieved_label == label {
                 // all good, let's a go
                 let mut p = self.path.clone();
-                p.push(self.encoding.encode(format!("{}.label", label.name)));
+                p.push(self.filename_encoding.encode(format!("{}.label", label.name)));
                 let mut options = fs::OpenOptions::new();
                 options.create(false);
                 options.write(true);
@@ -552,7 +568,7 @@ impl LabelStore for CachedDirectoryLabelStore {
         let mut labels = self.labels.write().await;
         if labels.remove(name).is_some() {
             let mut p = self.path.clone();
-            p.push(self.encoding.encode(format!("{}.label", name)));
+            p.push(self.filename_encoding.encode(format!("{}.label", name)));
             tokio::fs::remove_file(p).await?;
 
             Ok(true)
@@ -662,7 +678,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         let (stored, retrieved) = async {
             let stored = store.create_label("foo").await?;
@@ -680,7 +696,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_url_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding {});
 
         let (stored, retrieved) = async {
             let stored = store
@@ -702,7 +718,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_succeeds() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         let retrieved = async {
             let stored = store.create_label("foo").await?;
@@ -720,7 +736,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_twice_from_same_label_object_fails() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         let (stored2, stored3) = async {
             let stored1 = store.create_label("foo").await?;
@@ -740,7 +756,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_label_twice_errors() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         store.create_label("foo").await.unwrap();
         let result = store.create_label("foo").await;
@@ -860,7 +876,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_delete_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         store.create_label("foo").await.unwrap();
         assert!(store.get_label("foo").await.unwrap().is_some());
@@ -871,7 +887,7 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         assert!(!store.delete_label("foo").await.unwrap());
     }
@@ -879,7 +895,7 @@ mod tests {
     #[tokio::test]
     async fn delete_shared_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
@@ -891,7 +907,7 @@ mod tests {
     #[tokio::test]
     async fn delete_exclusive_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding{});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 337de941..7dd36efa 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -910,11 +910,16 @@ pub fn open_memory_store() -> Store {
 /// cache_size specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-/// filename_encoding specifies encoding strategy implemented using
-/// FilenameEncoding trait that is used to generate label file names
-/// from database labels (NoFilenameEncoding does no encoding;
-/// URLFilenameEncoding uses URL encoding algorithm).
-pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize, filename_encoding: impl FilenameEncoding + 'static) -> Store {
+/// filename_encoding specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_archive_store<P: Into<PathBuf>>(
+    path: P,
+    cache_size: usize,
+    filename_encoding: impl FilenameEncoding + 'static
+) -> Store {
     let p = path.into();
     let directory_archive_backend = DirectoryArchiveBackend::new(p.clone());
     let archive_backend = LruArchiveBackend::new(directory_archive_backend.clone(), cache_size);
@@ -931,11 +936,15 @@ pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize, filename
 
 /// Open a store that stores its data in the given directory.
 ///
-/// filename_encoding specifies encoding strategy implemented using
-/// FilenameEncoding trait that is used to generate label file names
-/// from database labels (NoFilenameEncoding does no encoding;
-/// URLFilenameEncoding uses URL encoding algorithm).
-pub fn open_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: impl FilenameEncoding + 'static) -> Store {
+/// filename_encoding specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_directory_store<P: Into<PathBuf>>(
+    path: P,
+    filename_encoding: impl FilenameEncoding + 'static
+) -> Store {
     let p = path.into();
     Store::new(
         DirectoryLabelStore::new(p.clone(), filename_encoding),
@@ -946,8 +955,8 @@ pub fn open_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: impl F
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::tempdir;
     use crate::storage::directory::NoFilenameEncoding;
+    use tempfile::tempdir;
 
     async fn create_and_manipulate_database(store: Store) {
         let database = store.create("foodb").await.unwrap();
@@ -989,7 +998,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_manipulate_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
 
         create_and_manipulate_database(store).await;
     }
@@ -1512,7 +1521,7 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
 
         cached_layer_name_does_not_change_after_rollup(store).await
     }
@@ -1558,14 +1567,14 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup_upto() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         cached_layer_name_does_not_change_after_rollup_upto(store).await
     }
 
     #[tokio::test]
     async fn force_update_with_matching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1580,7 +1589,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1595,7 +1604,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_matching_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1614,7 +1623,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatched_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1633,7 +1642,7 @@ mod tests {
     #[tokio::test]
     async fn delete_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let _ = store.create("foo").await.unwrap();
         assert!(store.delete("foo").await.unwrap());
         assert!(store.open("foo").await.unwrap().is_none());
@@ -1642,14 +1651,14 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         assert!(!store.delete("foo").await.unwrap());
     }
 
     #[tokio::test]
     async fn delete_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
         assert!(store.open("foo").await.unwrap().is_some());
         graph.delete().await.unwrap();
@@ -1659,7 +1668,7 @@ mod tests {
     #[tokio::test]
     async fn recreate_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         let graph = store.create("foo").await.unwrap();
         let builder = store.create_base_layer().await.unwrap();
         let layer = builder.commit().await.unwrap();
@@ -1673,7 +1682,7 @@ mod tests {
     #[tokio::test]
     async fn list_databases() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
         assert!(store.labels().await.unwrap().is_empty());
         let _ = store.create("foo").await.unwrap();
         let one = vec!["foo".to_string()];
diff --git a/src/store/sync.rs b/src/store/sync.rs
index 7dcb52f0..74092da5 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -600,11 +600,15 @@ pub fn open_sync_memory_store() -> SyncStore {
 
 /// Open a store that stores its data in the given directory.
 ///
-/// filename_encoding specifies encoding strategy implemented using
-/// FilenameEncoding trait that is used to generate label file names
-/// from database labels (NoFilenameEncoding does no encoding;
-/// URLFilenameEncoding uses URL encoding algorithm).
-pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: impl FilenameEncoding + 'static) -> SyncStore {
+/// filename_encoding specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_sync_directory_store<P: Into<PathBuf>>(
+    path: P,
+    filename_encoding: impl FilenameEncoding + 'static
+) -> SyncStore {
     SyncStore::wrap(open_directory_store(path, filename_encoding))
 }
 
@@ -613,19 +617,24 @@ pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P, filename_encoding: i
 /// cache_size specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-/// filename_encoding specifies encoding strategy implemented using
-/// FilenameEncoding trait that is used to generate label file names
-/// from database labels (NoFilenameEncoding does no encoding;
-/// URLFilenameEncoding uses URL encoding algorithm).
-pub fn open_sync_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize, filename_encoding: impl FilenameEncoding + 'static) -> SyncStore {
+/// filename_encoding specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_sync_archive_store<P: Into<PathBuf>>(
+    path: P,
+    cache_size: usize,
+    filename_encoding: impl FilenameEncoding + 'static
+) -> SyncStore {
     SyncStore::wrap(open_archive_store(path, cache_size, filename_encoding))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::tempdir;
     use crate::storage::directory::NoFilenameEncoding;
+    use tempfile::tempdir;
 
     #[test]
     fn create_and_manipulate_sync_memory_database() {
@@ -662,7 +671,7 @@ mod tests {
     #[test]
     fn create_and_manipulate_sync_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding{});
+        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding {});
         let database = store.create("foodb").unwrap();
 
         let head = database.head().unwrap();
@@ -727,10 +736,10 @@ mod tests {
     #[test]
     fn export_and_import_pack() {
         let dir1 = tempdir().unwrap();
-        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding{});
+        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding {});
 
         let dir2 = tempdir().unwrap();
-        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding{});
+        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding {});
 
         let builder1 = store1.create_base_layer().unwrap();
         builder1

From 86267ba902bd26d9aa6f0f3ec969a3076e9895d3 Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Thu, 30 Mar 2023 16:01:19 +0200
Subject: [PATCH 5/8] final code formatting

---
 src/storage/directory.rs | 12 ++++++++----
 src/store/mod.rs         |  4 ++--
 src/store/sync.rs        |  4 ++--
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 2ef6cc43..a6016351 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -223,7 +223,7 @@ pub struct DirectoryLabelStore {
 impl DirectoryLabelStore {
     pub fn new<P: Into<PathBuf>>(
         path: P,
-        filename_encoding: impl FilenameEncoding + 'static
+        filename_encoding: impl FilenameEncoding + 'static,
     ) -> DirectoryLabelStore {
         DirectoryLabelStore {
             path: path.into(),
@@ -449,7 +449,7 @@ impl CachedDirectoryLabelStore {
     /// this is an async operation.
     pub async fn open<P: Into<PathBuf>>(
         path: P,
-        filename_encoding: impl FilenameEncoding + 'static
+        filename_encoding: impl FilenameEncoding + 'static,
     ) -> io::Result<Self> {
         let path: PathBuf = path.into();
         let mut labels = HashMap::new();
@@ -466,7 +466,8 @@ impl CachedDirectoryLabelStore {
 
                 let label_name = file_name[..file_name.len() - 6].to_string();
                 let label =
-                    get_label_from_file(entry.path(), filename_encoding.decode(label_name.clone())).await?;
+                    get_label_from_file(entry.path(), filename_encoding.decode(label_name.clone()))
+                        .await?;
 
                 labels.insert(label_name, label);
             }
@@ -545,7 +546,10 @@ impl LabelStore for CachedDirectoryLabelStore {
             if retrieved_label == label {
                 // all good, let's a go
                 let mut p = self.path.clone();
-                p.push(self.filename_encoding.encode(format!("{}.label", label.name)));
+                p.push(
+                    self.filename_encoding
+                        .encode(format!("{}.label", label.name)),
+                );
                 let mut options = fs::OpenOptions::new();
                 options.create(false);
                 options.write(true);
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 7dd36efa..e50250fa 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -918,7 +918,7 @@ pub fn open_memory_store() -> Store {
 pub fn open_archive_store<P: Into<PathBuf>>(
     path: P,
     cache_size: usize,
-    filename_encoding: impl FilenameEncoding + 'static
+    filename_encoding: impl FilenameEncoding + 'static,
 ) -> Store {
     let p = path.into();
     let directory_archive_backend = DirectoryArchiveBackend::new(p.clone());
@@ -943,7 +943,7 @@ pub fn open_archive_store<P: Into<PathBuf>>(
 /// encoding algorithm.
 pub fn open_directory_store<P: Into<PathBuf>>(
     path: P,
-    filename_encoding: impl FilenameEncoding + 'static
+    filename_encoding: impl FilenameEncoding + 'static,
 ) -> Store {
     let p = path.into();
     Store::new(
diff --git a/src/store/sync.rs b/src/store/sync.rs
index 74092da5..e6dd5ab4 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -607,7 +607,7 @@ pub fn open_sync_memory_store() -> SyncStore {
 /// encoding algorithm.
 pub fn open_sync_directory_store<P: Into<PathBuf>>(
     path: P,
-    filename_encoding: impl FilenameEncoding + 'static
+    filename_encoding: impl FilenameEncoding + 'static,
 ) -> SyncStore {
     SyncStore::wrap(open_directory_store(path, filename_encoding))
 }
@@ -625,7 +625,7 @@ pub fn open_sync_directory_store<P: Into<PathBuf>>(
 pub fn open_sync_archive_store<P: Into<PathBuf>>(
     path: P,
     cache_size: usize,
-    filename_encoding: impl FilenameEncoding + 'static
+    filename_encoding: impl FilenameEncoding + 'static,
 ) -> SyncStore {
     SyncStore::wrap(open_archive_store(path, cache_size, filename_encoding))
 }

From 51bb3b9c62a64a0df480e871dc4f81184c3650b3 Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Fri, 31 Mar 2023 12:03:14 +0200
Subject: [PATCH 6/8] curly-brace free empty structs

---
 benches/bench.rs           |  2 +-
 benches/builder/main.rs    | 10 +++++-----
 examples/create_graph.rs   |  2 +-
 examples/print_graph.rs    |  2 +-
 examples/write_to_graph.rs |  2 +-
 src/storage/directory.rs   | 22 +++++++++++-----------
 src/store/mod.rs           | 24 ++++++++++++------------
 src/store/sync.rs          |  6 +++---
 8 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/benches/bench.rs b/benches/bench.rs
index 00881c73..f86c2ceb 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -10,7 +10,7 @@ use test::Bencher;
 #[bench]
 fn bench_add_string_triple(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let layer_builder = sync_store.create_base_layer().unwrap();
     let mut count = 1;
     b.iter(|| {
diff --git a/benches/builder/main.rs b/benches/builder/main.rs
index bf26f891..63a48a41 100644
--- a/benches/builder/main.rs
+++ b/benches/builder/main.rs
@@ -13,7 +13,7 @@ use data::*;
 #[bench]
 fn build_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     b.iter(|| {
         let builder = store.create_base_layer().unwrap();
@@ -24,7 +24,7 @@ fn build_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_base_layer_1000(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
@@ -49,7 +49,7 @@ fn build_base_layer_1000(b: &mut Bencher) {
 #[bench]
 fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -62,7 +62,7 @@ fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -89,7 +89,7 @@ fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_nonempty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
diff --git a/examples/create_graph.rs b/examples/create_graph.rs
index 9d4d701d..7bbacedc 100644
--- a/examples/create_graph.rs
+++ b/examples/create_graph.rs
@@ -11,7 +11,7 @@ async fn main() {
         println!("usage: {} <path> <graph_name>", args[0]);
     } else {
         // open a store at the given path. the directory has to exist.
-        let store = open_directory_store(&args[1], NoFilenameEncoding {});
+        let store = open_directory_store(&args[1], NoFilenameEncoding);
 
         // then create a graph. if the graph already exists, this will error.
         store.create(&args[2]).await.unwrap();
diff --git a/examples/print_graph.rs b/examples/print_graph.rs
index 66815976..ae07b1a3 100644
--- a/examples/print_graph.rs
+++ b/examples/print_graph.rs
@@ -7,7 +7,7 @@ use terminus_store::*;
 use tokio;
 
 async fn print_graph(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path, NoFilenameEncoding {});
+    let store = open_directory_store(store_path, NoFilenameEncoding);
     let graph = store
         .open(graph)
         .await?
diff --git a/examples/write_to_graph.rs b/examples/write_to_graph.rs
index d188c4f0..cb68507d 100644
--- a/examples/write_to_graph.rs
+++ b/examples/write_to_graph.rs
@@ -53,7 +53,7 @@ async fn parse_command(s: &str) -> io::Result<Command> {
 }
 
 async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path, NoFilenameEncoding {});
+    let store = open_directory_store(store_path, NoFilenameEncoding);
     let graph = store
         .open(graph)
         .await?
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index a6016351..3506f832 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -191,7 +191,7 @@ pub trait FilenameEncoding: DynClone + Send + Sync {
 clone_trait_object!(FilenameEncoding);
 
 #[derive(Clone)]
-pub struct NoFilenameEncoding {}
+pub struct NoFilenameEncoding;
 
 impl FilenameEncoding for NoFilenameEncoding {
     fn encode(&self, str: String) -> String {
@@ -203,7 +203,7 @@ impl FilenameEncoding for NoFilenameEncoding {
 }
 
 #[derive(Clone)]
-pub struct URLFilenameEncoding {}
+pub struct URLFilenameEncoding;
 
 impl FilenameEncoding for URLFilenameEncoding {
     fn encode(&self, str: String) -> String {
@@ -682,7 +682,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let (stored, retrieved) = async {
             let stored = store.create_label("foo").await?;
@@ -700,7 +700,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_url_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding);
 
         let (stored, retrieved) = async {
             let stored = store
@@ -722,7 +722,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_succeeds() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let retrieved = async {
             let stored = store.create_label("foo").await?;
@@ -740,7 +740,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_twice_from_same_label_object_fails() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let (stored2, stored3) = async {
             let stored1 = store.create_label("foo").await?;
@@ -760,7 +760,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_label_twice_errors() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let result = store.create_label("foo").await;
@@ -880,7 +880,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_delete_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         assert!(store.get_label("foo").await.unwrap().is_some());
@@ -891,7 +891,7 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         assert!(!store.delete_label("foo").await.unwrap());
     }
@@ -899,7 +899,7 @@ mod tests {
     #[tokio::test]
     async fn delete_shared_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
@@ -911,7 +911,7 @@ mod tests {
     #[tokio::test]
     async fn delete_exclusive_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding {});
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
diff --git a/src/store/mod.rs b/src/store/mod.rs
index e50250fa..1e7edbd9 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -998,7 +998,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_manipulate_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
 
         create_and_manipulate_database(store).await;
     }
@@ -1521,7 +1521,7 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
 
         cached_layer_name_does_not_change_after_rollup(store).await
     }
@@ -1567,14 +1567,14 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup_upto() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         cached_layer_name_does_not_change_after_rollup_upto(store).await
     }
 
     #[tokio::test]
     async fn force_update_with_matching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1589,7 +1589,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1604,7 +1604,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_matching_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1623,7 +1623,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatched_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1642,7 +1642,7 @@ mod tests {
     #[tokio::test]
     async fn delete_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let _ = store.create("foo").await.unwrap();
         assert!(store.delete("foo").await.unwrap());
         assert!(store.open("foo").await.unwrap().is_none());
@@ -1651,14 +1651,14 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         assert!(!store.delete("foo").await.unwrap());
     }
 
     #[tokio::test]
     async fn delete_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         assert!(store.open("foo").await.unwrap().is_some());
         graph.delete().await.unwrap();
@@ -1668,7 +1668,7 @@ mod tests {
     #[tokio::test]
     async fn recreate_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let builder = store.create_base_layer().await.unwrap();
         let layer = builder.commit().await.unwrap();
@@ -1682,7 +1682,7 @@ mod tests {
     #[tokio::test]
     async fn list_databases() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         assert!(store.labels().await.unwrap().is_empty());
         let _ = store.create("foo").await.unwrap();
         let one = vec!["foo".to_string()];
diff --git a/src/store/sync.rs b/src/store/sync.rs
index e6dd5ab4..a8132d93 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -671,7 +671,7 @@ mod tests {
     #[test]
     fn create_and_manipulate_sync_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding {});
+        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding);
         let database = store.create("foodb").unwrap();
 
         let head = database.head().unwrap();
@@ -736,10 +736,10 @@ mod tests {
     #[test]
     fn export_and_import_pack() {
         let dir1 = tempdir().unwrap();
-        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding {});
+        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding);
 
         let dir2 = tempdir().unwrap();
-        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding {});
+        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding);
 
         let builder1 = store1.create_base_layer().unwrap();
         builder1

From d4b7c20b6ab25169f9ba0e27a4b4535a925baafd Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Fri, 31 Mar 2023 17:42:46 +0200
Subject: [PATCH 7/8] improved documentation

---
 src/storage/directory.rs | 3 +++
 src/store/mod.rs         | 6 +++---
 src/store/sync.rs        | 6 +++---
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 3506f832..bb5e0c4f 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -183,6 +183,7 @@ impl PersistentLayerStore for DirectoryLayerStore {
     }
 }
 
+/// Encoding of the file names
 pub trait FilenameEncoding: DynClone + Send + Sync {
     fn encode(&self, str: String) -> String;
     fn decode(&self, str: String) -> String;
@@ -190,6 +191,7 @@ pub trait FilenameEncoding: DynClone + Send + Sync {
 
 clone_trait_object!(FilenameEncoding);
 
+/// Bypassing encoding of the file name
 #[derive(Clone)]
 pub struct NoFilenameEncoding;
 
@@ -202,6 +204,7 @@ impl FilenameEncoding for NoFilenameEncoding {
     }
 }
 
+/// URL encoding of the file name
 #[derive(Clone)]
 pub struct URLFilenameEncoding;
 
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 1e7edbd9..521cba02 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -907,10 +907,10 @@ pub fn open_memory_store() -> Store {
 
 /// Open a store that stores its data in the given directory as archive files.
 ///
-/// cache_size specifies in megabytes how large the LRU cache should
+/// * `cache_size` - specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-/// filename_encoding specifies how database label is converted into
+/// * `filename_encoding` - specifies how database label is converted into
 /// label file name (pluggable methods must implement FilenameEncoding
 /// trait). Two implementations are provided: NoFilenameEncoding does
 /// no convertion; URLFilenameEncoding convertion is based on URL
@@ -936,7 +936,7 @@ pub fn open_archive_store<P: Into<PathBuf>>(
 
 /// Open a store that stores its data in the given directory.
 ///
-/// filename_encoding specifies how database label is converted into
+/// * `filename_encoding` -  specifies how database label is converted into
 /// label file name (pluggable methods must implement FilenameEncoding
 /// trait). Two implementations are provided: NoFilenameEncoding does
 /// no convertion; URLFilenameEncoding convertion is based on URL
diff --git a/src/store/sync.rs b/src/store/sync.rs
index a8132d93..56d7d7e6 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -600,7 +600,7 @@ pub fn open_sync_memory_store() -> SyncStore {
 
 /// Open a store that stores its data in the given directory.
 ///
-/// filename_encoding specifies how database label is converted into
+/// * `filename_encoding` - specifies how database label is converted into
 /// label file name (pluggable methods must implement FilenameEncoding
 /// trait). Two implementations are provided: NoFilenameEncoding does
 /// no convertion; URLFilenameEncoding convertion is based on URL
@@ -614,10 +614,10 @@ pub fn open_sync_directory_store<P: Into<PathBuf>>(
 
 /// Open a store that stores its data in the given directory as archive files.
 ///
-/// cache_size specifies in megabytes how large the LRU cache should
+/// * `cache_size` - specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-/// filename_encoding specifies how database label is converted into
+/// * `filename_encoding` - specifies how database label is converted into
 /// label file name (pluggable methods must implement FilenameEncoding
 /// trait). Two implementations are provided: NoFilenameEncoding does
 /// no convertion; URLFilenameEncoding convertion is based on URL

From 09a48ef8666aa1d8480f3ef4fb224dd94706475b Mon Sep 17 00:00:00 2001
From: Leonid Mokrushin <leonid.mokrushin@ericsson.com>
Date: Fri, 31 Mar 2023 17:47:40 +0200
Subject: [PATCH 8/8] fixed doc warnings

---
 src/storage/pack.rs | 2 +-
 src/store/mod.rs    | 2 +-
 src/store/sync.rs   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/storage/pack.rs b/src/storage/pack.rs
index 88002a8e..3446e82a 100644
--- a/src/storage/pack.rs
+++ b/src/storage/pack.rs
@@ -19,7 +19,7 @@ use tokio::io::AsyncWriteExt;
 
 #[async_trait]
 pub trait Packable {
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     async fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 521cba02..f8df9fb1 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -873,7 +873,7 @@ impl Store {
         StoreLayerBuilder::new(self.clone()).await
     }
 
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     pub async fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,
diff --git a/src/store/sync.rs b/src/store/sync.rs
index 56d7d7e6..b5ec2000 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -569,7 +569,7 @@ impl SyncStore {
         inner.map(SyncStoreLayerBuilder::wrap)
     }
 
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     pub fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,