From 5eab757ae14d865d3ec0c3a3c055e1b895d8643a Mon Sep 17 00:00:00 2001
From: Lachlan Deakin <ljdgit@gmail.com>
Date: Sat, 10 Feb 2024 21:17:50 +1100
Subject: [PATCH] Remove `Arc` storage type lifetimes and enforce storage
 transformers be `Arc` wrapped

---
 CHANGELOG.md                                  |  3 +
 examples/http_array_read.rs                   |  4 +-
 examples/sharded_array_write_read.rs          | 12 ++-
 examples/zip_array_write_read.rs              |  4 +-
 src/array/array_async_readable.rs             | 10 +-
 src/array/array_async_readable_writable.rs    |  2 +-
 src/array/array_async_writable.rs             | 10 +-
 src/array/array_sync_readable.rs              |  8 +-
 src/array/array_sync_readable_writable.rs     |  2 +-
 src/array/array_sync_writable.rs              | 10 +-
 src/array/codec.rs                            | 20 ++--
 src/group.rs                                  |  6 +-
 src/storage.rs                                | 18 ++--
 src/storage/storage_handle.rs                 | 30 +++---
 src/storage/storage_transformer.rs            | 63 ++++++-------
 .../performance_metrics.rs                    | 87 ++++++++---------
 .../storage_transformer_chain.rs              | 93 ++++++++++---------
 src/storage/storage_transformer/usage_log.rs  | 58 ++++++------
 18 files changed, 214 insertions(+), 226 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4dc4efe1..c41ed498 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  - **Breaking**: use `IncompatibleArraySubsetAndShapeError` in `ArrayStoreBytesError::InvalidArrayShape`
  - Increase coverage for:
    - `array_subset_iterators.rs`
+ - **Major breaking**: storage transformers must be `Arc` wrapped as `StorageTransformerExtension` trait method now take `self: Arc<Self>`
+ - Removed lifetimes from `{Async}{Readable,Writable,ReadableWritable,Listable,ReadableListable}Storage`
+ - **Breaking**: `Group` and `Array` methods generic on storage now require the storage with a `'static` lifetime
 
 ### Removed
  - **Breaking**: remove `InvalidArraySubsetError` and `ArrayExtractElementsError`
diff --git a/examples/http_array_read.rs b/examples/http_array_read.rs
index d27523bb..1d745e7c 100644
--- a/examples/http_array_read.rs
+++ b/examples/http_array_read.rs
@@ -20,9 +20,9 @@ fn http_array_read() -> Result<(), Box<dyn std::error::Error>> {
         std::io::stdout(),
         //    )
     ));
-    let usage_log = UsageLogStorageTransformer::new(log_writer, || {
+    let usage_log = Arc::new(UsageLogStorageTransformer::new(log_writer, || {
         chrono::Utc::now().format("[%T%.3f] ").to_string()
-    });
+    }));
     let store = usage_log.create_readable_transformer(store);
 
     // Init the existing array, reading metadata
diff --git a/examples/sharded_array_write_read.rs b/examples/sharded_array_write_read.rs
index dbb232a1..3647e529 100644
--- a/examples/sharded_array_write_read.rs
+++ b/examples/sharded_array_write_read.rs
@@ -27,11 +27,15 @@ fn sharded_array_write_read() -> Result<(), Box<dyn std::error::Error>> {
         std::io::stdout(),
         //    )
     ));
-    let usage_log = UsageLogStorageTransformer::new(log_writer, || {
+    let usage_log = Arc::new(UsageLogStorageTransformer::new(log_writer, || {
         chrono::Utc::now().format("[%T%.3f] ").to_string()
-    });
-    let store_readable_listable = usage_log.create_readable_listable_transformer(store.clone());
-    let store = usage_log.create_readable_writable_transformer(store);
+    }));
+    let store_readable_listable = usage_log
+        .clone()
+        .create_readable_listable_transformer(store.clone());
+    let store = usage_log
+        .clone()
+        .create_readable_writable_transformer(store);
 
     // Create a group
     let group_path = "/group";
diff --git a/examples/zip_array_write_read.rs b/examples/zip_array_write_read.rs
index f60a9541..a94c7cb9 100644
--- a/examples/zip_array_write_read.rs
+++ b/examples/zip_array_write_read.rs
@@ -14,7 +14,7 @@ use zarrs::{
 // const ARRAY_PATH: &'static str = "/array";
 const ARRAY_PATH: &str = "/";
 
-fn write_array_to_storage<TStorage: ReadableWritableStorageTraits>(
+fn write_array_to_storage<TStorage: ReadableWritableStorageTraits + 'static>(
     storage: Arc<TStorage>,
 ) -> Result<Array<TStorage>, Box<dyn std::error::Error>> {
     use zarrs::array::{chunk_grid::ChunkGridTraits, codec, DataType, FillValue};
@@ -87,7 +87,7 @@ fn write_array_to_storage<TStorage: ReadableWritableStorageTraits>(
     Ok(array)
 }
 
-fn read_array_from_store<TStorage: ReadableStorageTraits>(
+fn read_array_from_store<TStorage: ReadableStorageTraits + 'static>(
     array: Array<TStorage>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     // Read the whole array
diff --git a/src/array/array_async_readable.rs b/src/array/array_async_readable.rs
index edda2cc8..8eb52b66 100644
--- a/src/array/array_async_readable.rs
+++ b/src/array/array_async_readable.rs
@@ -22,7 +22,7 @@ use super::{
 #[cfg(feature = "ndarray")]
 use super::elements_to_ndarray;
 
-impl<TStorage: ?Sized + AsyncReadableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + AsyncReadableStorageTraits + 'static> Array<TStorage> {
     /// Create an array in `storage` at `path`. The metadata is read from the store.
     ///
     /// # Errors
@@ -54,7 +54,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> Array<TStorage> {
         &self,
         chunk_indices: &[u64],
     ) -> Result<Option<Vec<u8>>, ArrayError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_readable_transformer(storage_handle);
@@ -438,7 +438,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> Array<TStorage> {
                                 overlap.relative_to_unchecked(chunk_subset_in_array.start())
                             };
 
-                            let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+                            let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
                             let storage_transformer = self
                                 .storage_transformers()
                                 .create_async_readable_transformer(storage_handle);
@@ -565,7 +565,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> Array<TStorage> {
             ));
         }
 
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_readable_transformer(storage_handle);
@@ -646,7 +646,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> Array<TStorage> {
         chunk_indices: &[u64],
         parallel: bool,
     ) -> Result<Box<dyn AsyncArrayPartialDecoderTraits + 'a>, ArrayError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_readable_transformer(storage_handle);
diff --git a/src/array/array_async_readable_writable.rs b/src/array/array_async_readable_writable.rs
index f9d56943..917d6951 100644
--- a/src/array/array_async_readable_writable.rs
+++ b/src/array/array_async_readable_writable.rs
@@ -7,7 +7,7 @@ use crate::{
 
 use super::{Array, ArrayError};
 
-impl<TStorage: ?Sized + AsyncReadableWritableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + AsyncReadableWritableStorageTraits + 'static> Array<TStorage> {
     /// Encode `subset_bytes` and store in `array_subset`.
     ///
     /// If `parallel` is true, chunks intersecting the array subset are retrieved in parallel.
diff --git a/src/array/array_async_writable.rs b/src/array/array_async_writable.rs
index 7115fee0..e4a976cc 100644
--- a/src/array/array_async_writable.rs
+++ b/src/array/array_async_writable.rs
@@ -9,13 +9,13 @@ use crate::{
 
 use super::{codec::ArrayCodecTraits, Array, ArrayError};
 
-impl<TStorage: ?Sized + AsyncWritableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + AsyncWritableStorageTraits + 'static> Array<TStorage> {
     /// Store metadata.
     ///
     /// # Errors
     /// Returns [`StorageError`] if there is an underlying store error.
     pub async fn async_store_metadata(&self) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_writable_transformer(storage_handle);
@@ -52,7 +52,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> Array<TStorage> {
             self.async_erase_chunk(chunk_indices).await?;
             Ok(())
         } else {
-            let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+            let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
             let storage_transformer = self
                 .storage_transformers()
                 .create_async_writable_transformer(storage_handle);
@@ -234,7 +234,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> Array<TStorage> {
     /// # Errors
     /// Returns a [`StorageError`] if there is an underlying store error.
     pub async fn async_erase_chunk(&self, chunk_indices: &[u64]) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_writable_transformer(storage_handle);
@@ -252,7 +252,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> Array<TStorage> {
     /// # Errors
     /// Returns a [`StorageError`] if there is an underlying store error.
     pub async fn async_erase_chunks(&self, chunks: &ArraySubset) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_async_writable_transformer(storage_handle);
diff --git a/src/array/array_sync_readable.rs b/src/array/array_sync_readable.rs
index d9cc1ff7..2f12b3e5 100644
--- a/src/array/array_sync_readable.rs
+++ b/src/array/array_sync_readable.rs
@@ -20,7 +20,7 @@ use super::{
 #[cfg(feature = "ndarray")]
 use super::elements_to_ndarray;
 
-impl<TStorage: ?Sized + ReadableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + ReadableStorageTraits + 'static> Array<TStorage> {
     /// Create an array in `storage` at `path`. The metadata is read from the store.
     ///
     /// # Errors
@@ -51,7 +51,7 @@ impl<TStorage: ?Sized + ReadableStorageTraits> Array<TStorage> {
         &self,
         chunk_indices: &[u64],
     ) -> Result<Option<Vec<u8>>, ArrayError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_readable_transformer(storage_handle);
@@ -641,7 +641,7 @@ impl<TStorage: ?Sized + ReadableStorageTraits> Array<TStorage> {
             ));
         }
 
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_readable_transformer(storage_handle);
@@ -716,7 +716,7 @@ impl<TStorage: ?Sized + ReadableStorageTraits> Array<TStorage> {
         chunk_indices: &[u64],
         parallel: bool,
     ) -> Result<Box<dyn ArrayPartialDecoderTraits + 'a>, ArrayError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_readable_transformer(storage_handle);
diff --git a/src/array/array_sync_readable_writable.rs b/src/array/array_sync_readable_writable.rs
index a9c33132..45b0012e 100644
--- a/src/array/array_sync_readable_writable.rs
+++ b/src/array/array_sync_readable_writable.rs
@@ -7,7 +7,7 @@ use crate::{
 
 use super::{unravel_index, Array, ArrayError};
 
-impl<TStorage: ?Sized + ReadableWritableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + ReadableWritableStorageTraits + 'static> Array<TStorage> {
     /// Encode `subset_bytes` and store in `array_subset`.
     ///
     /// If `parallel` is true, chunks intersecting the array subset are retrieved in parallel.
diff --git a/src/array/array_sync_writable.rs b/src/array/array_sync_writable.rs
index 8ea826e8..8e382997 100644
--- a/src/array/array_sync_writable.rs
+++ b/src/array/array_sync_writable.rs
@@ -9,13 +9,13 @@ use crate::{
 
 use super::{codec::ArrayCodecTraits, unravel_index, Array, ArrayError};
 
-impl<TStorage: ?Sized + WritableStorageTraits> Array<TStorage> {
+impl<TStorage: ?Sized + WritableStorageTraits + 'static> Array<TStorage> {
     /// Store metadata.
     ///
     /// # Errors
     /// Returns [`StorageError`] if there is an underlying store error.
     pub fn store_metadata(&self) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_writable_transformer(storage_handle);
@@ -51,7 +51,7 @@ impl<TStorage: ?Sized + WritableStorageTraits> Array<TStorage> {
             self.erase_chunk(chunk_indices)?;
             Ok(())
         } else {
-            let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+            let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
             let storage_transformer = self
                 .storage_transformers()
                 .create_writable_transformer(storage_handle);
@@ -315,7 +315,7 @@ impl<TStorage: ?Sized + WritableStorageTraits> Array<TStorage> {
     /// # Errors
     /// Returns a [`StorageError`] if there is an underlying store error.
     pub fn erase_chunk(&self, chunk_indices: &[u64]) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_writable_transformer(storage_handle);
@@ -336,7 +336,7 @@ impl<TStorage: ?Sized + WritableStorageTraits> Array<TStorage> {
         chunks: &ArraySubset,
         parallel: bool,
     ) -> Result<(), StorageError> {
-        let storage_handle = Arc::new(StorageHandle::new(&*self.storage));
+        let storage_handle = Arc::new(StorageHandle::new(self.storage.clone()));
         let storage_transformer = self
             .storage_transformers()
             .create_writable_transformer(storage_handle);
diff --git a/src/array/codec.rs b/src/array/codec.rs
index dceef83e..85995390 100644
--- a/src/array/codec.rs
+++ b/src/array/codec.rs
@@ -517,19 +517,19 @@ pub trait AsyncArrayPartialDecoderTraits: Send + Sync {
 }
 
 /// A [`ReadableStorage`] partial decoder.
-pub struct StoragePartialDecoder<'a> {
-    storage: ReadableStorage<'a>,
+pub struct StoragePartialDecoder {
+    storage: ReadableStorage,
     key: StoreKey,
 }
 
-impl<'a> StoragePartialDecoder<'a> {
+impl StoragePartialDecoder {
     /// Create a new storage partial decoder.
-    pub fn new(storage: ReadableStorage<'a>, key: StoreKey) -> Self {
+    pub fn new(storage: ReadableStorage, key: StoreKey) -> Self {
         Self { storage, key }
     }
 }
 
-impl BytesPartialDecoderTraits for StoragePartialDecoder<'_> {
+impl BytesPartialDecoderTraits for StoragePartialDecoder {
     fn partial_decode_opt(
         &self,
         decoded_regions: &[ByteRange],
@@ -543,22 +543,22 @@ impl BytesPartialDecoderTraits for StoragePartialDecoder<'_> {
 
 #[cfg(feature = "async")]
 /// A [`ReadableStorage`] partial decoder.
-pub struct AsyncStoragePartialDecoder<'a> {
-    storage: AsyncReadableStorage<'a>,
+pub struct AsyncStoragePartialDecoder {
+    storage: AsyncReadableStorage,
     key: StoreKey,
 }
 
 #[cfg(feature = "async")]
-impl<'a> AsyncStoragePartialDecoder<'a> {
+impl AsyncStoragePartialDecoder {
     /// Create a new storage partial decoder.
-    pub fn new(storage: AsyncReadableStorage<'a>, key: StoreKey) -> Self {
+    pub fn new(storage: AsyncReadableStorage, key: StoreKey) -> Self {
         Self { storage, key }
     }
 }
 
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
-impl AsyncBytesPartialDecoderTraits for AsyncStoragePartialDecoder<'_> {
+impl AsyncBytesPartialDecoderTraits for AsyncStoragePartialDecoder {
     async fn partial_decode_opt(
         &self,
         decoded_regions: &[ByteRange],
diff --git a/src/group.rs b/src/group.rs
index a366cb76..95b5446c 100644
--- a/src/group.rs
+++ b/src/group.rs
@@ -193,14 +193,14 @@ fn validate_group_metadata(metadata: &GroupMetadataV3) -> Result<(), GroupCreate
 
 impl<TStorage: ?Sized + ReadableStorageTraits> Group<TStorage> {}
 
-impl<TStorage: ?Sized + WritableStorageTraits> Group<TStorage> {
+impl<TStorage: ?Sized + WritableStorageTraits + 'static> Group<TStorage> {
     /// Store metadata.
     ///
     /// # Errors
     ///
     /// Returns [`StorageError`] if there is an underlying store error.
     pub fn store_metadata(&self) -> Result<(), StorageError> {
-        let storage_handle = StorageHandle::new(&*self.storage);
+        let storage_handle = StorageHandle::new(self.storage.clone());
         crate::storage::create_group(&storage_handle, self.path(), &self.metadata())
     }
 }
@@ -213,7 +213,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> Group<TStorage> {
     ///
     /// Returns [`StorageError`] if there is an underlying store error.
     pub async fn async_store_metadata(&self) -> Result<(), StorageError> {
-        let storage_handle = StorageHandle::new(&*self.storage);
+        let storage_handle = StorageHandle::new(self.storage.clone());
         crate::storage::async_create_group(&storage_handle, self.path(), &self.metadata()).await
     }
 }
diff --git a/src/storage.rs b/src/storage.rs
index 8f44b2dc..4d7618a3 100644
--- a/src/storage.rs
+++ b/src/storage.rs
@@ -60,35 +60,35 @@ pub use self::storage_handle::StorageHandle;
 pub use storage_value_io::StorageValueIO;
 
 /// [`Arc`] wrapped readable storage.
-pub type ReadableStorage<'a> = Arc<dyn ReadableStorageTraits + 'a>;
+pub type ReadableStorage = Arc<dyn ReadableStorageTraits>;
 
 /// [`Arc`] wrapped writable storage.
-pub type WritableStorage<'a> = Arc<dyn WritableStorageTraits + 'a>;
+pub type WritableStorage = Arc<dyn WritableStorageTraits>;
 
 /// [`Arc`] wrapped readable and writable storage.
-pub type ReadableWritableStorage<'a> = Arc<dyn ReadableWritableStorageTraits + 'a>;
+pub type ReadableWritableStorage = Arc<dyn ReadableWritableStorageTraits>;
 
 /// [`Arc`] wrapped listable storage.
-pub type ListableStorage<'a> = Arc<dyn ListableStorageTraits + 'a>;
+pub type ListableStorage = Arc<dyn ListableStorageTraits>;
 
 /// [`Arc`] wrapped readable and listable storage.
-pub type ReadableListableStorage<'a> = Arc<dyn ReadableListableStorageTraits + 'a>;
+pub type ReadableListableStorage = Arc<dyn ReadableListableStorageTraits>;
 
 #[cfg(feature = "async")]
 /// [`Arc`] wrapped asynchronous readable storage.
-pub type AsyncReadableStorage<'a> = Arc<dyn AsyncReadableStorageTraits + 'a>;
+pub type AsyncReadableStorage = Arc<dyn AsyncReadableStorageTraits>;
 
 #[cfg(feature = "async")]
 /// [`Arc`] wrapped asynchronous writable storage.
-pub type AsyncWritableStorage<'a> = Arc<dyn AsyncWritableStorageTraits + 'a>;
+pub type AsyncWritableStorage = Arc<dyn AsyncWritableStorageTraits>;
 
 #[cfg(feature = "async")]
 /// [`Arc`] wrapped asynchronous listable storage.
-pub type AsyncListableStorage<'a> = Arc<dyn AsyncListableStorageTraits + 'a>;
+pub type AsyncListableStorage = Arc<dyn AsyncListableStorageTraits>;
 
 #[cfg(feature = "async")]
 /// [`Arc`] wrapped asynchronous readable and listable storage.
-pub type AsyncReadableListableStorage<'a> = Arc<dyn AsyncReadableListableStorageTraits + 'a>;
+pub type AsyncReadableListableStorage = Arc<dyn AsyncReadableListableStorageTraits>;
 
 /// A [`StoreKey`] and [`ByteRange`].
 #[derive(Debug, Clone)]
diff --git a/src/storage/storage_handle.rs b/src/storage/storage_handle.rs
index dc4a928d..3e97781c 100644
--- a/src/storage/storage_handle.rs
+++ b/src/storage/storage_handle.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use crate::{array::MaybeBytes, byte_range::ByteRange};
 
 use super::{
@@ -15,18 +17,16 @@ use super::{
 ///
 /// This is a handle to borrowed storage which can be owned and cloned, even if the storage it references is unsized.
 #[derive(Clone)]
-pub struct StorageHandle<'a, TStorage: ?Sized>(&'a TStorage);
+pub struct StorageHandle<TStorage: ?Sized>(Arc<TStorage>);
 
-impl<'a, TStorage: ?Sized> StorageHandle<'a, TStorage> {
+impl<TStorage: ?Sized> StorageHandle<TStorage> {
     /// Create a new storage handle.
-    pub const fn new(storage: &'a TStorage) -> Self {
+    pub const fn new(storage: Arc<TStorage>) -> Self {
         Self(storage)
     }
 }
 
-impl<TStorage: ?Sized + ReadableStorageTraits> ReadableStorageTraits
-    for StorageHandle<'_, TStorage>
-{
+impl<TStorage: ?Sized + ReadableStorageTraits> ReadableStorageTraits for StorageHandle<TStorage> {
     fn get(&self, key: &super::StoreKey) -> Result<MaybeBytes, super::StorageError> {
         self.0.get(key)
     }
@@ -59,9 +59,7 @@ impl<TStorage: ?Sized + ReadableStorageTraits> ReadableStorageTraits
     }
 }
 
-impl<TStorage: ?Sized + ListableStorageTraits> ListableStorageTraits
-    for StorageHandle<'_, TStorage>
-{
+impl<TStorage: ?Sized + ListableStorageTraits> ListableStorageTraits for StorageHandle<TStorage> {
     fn list(&self) -> Result<super::StoreKeys, super::StorageError> {
         self.0.list()
     }
@@ -81,9 +79,7 @@ impl<TStorage: ?Sized + ListableStorageTraits> ListableStorageTraits
     }
 }
 
-impl<TStorage: ?Sized + WritableStorageTraits> WritableStorageTraits
-    for StorageHandle<'_, TStorage>
-{
+impl<TStorage: ?Sized + WritableStorageTraits> WritableStorageTraits for StorageHandle<TStorage> {
     fn set(&self, key: &super::StoreKey, value: &[u8]) -> Result<(), super::StorageError> {
         self.0.set(key, value)
     }
@@ -109,7 +105,7 @@ impl<TStorage: ?Sized + WritableStorageTraits> WritableStorageTraits
 }
 
 impl<TStorage: ?Sized + ReadableWritableStorageTraits> ReadableWritableStorageTraits
-    for StorageHandle<'_, TStorage>
+    for StorageHandle<TStorage>
 {
     fn mutex(&self, key: &StoreKey) -> Result<StoreKeyMutex, StorageError> {
         self.0.mutex(key)
@@ -119,7 +115,7 @@ impl<TStorage: ?Sized + ReadableWritableStorageTraits> ReadableWritableStorageTr
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncReadableStorageTraits> AsyncReadableStorageTraits
-    for StorageHandle<'_, TStorage>
+    for StorageHandle<TStorage>
 {
     async fn get(&self, key: &super::StoreKey) -> Result<MaybeBytes, super::StorageError> {
         self.0.get(key).await
@@ -156,7 +152,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> AsyncReadableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncListableStorageTraits> AsyncListableStorageTraits
-    for StorageHandle<'_, TStorage>
+    for StorageHandle<TStorage>
 {
     async fn list(&self) -> Result<super::StoreKeys, super::StorageError> {
         self.0.list().await
@@ -180,7 +176,7 @@ impl<TStorage: ?Sized + AsyncListableStorageTraits> AsyncListableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncWritableStorageTraits> AsyncWritableStorageTraits
-    for StorageHandle<'_, TStorage>
+    for StorageHandle<TStorage>
 {
     async fn set(&self, key: &StoreKey, value: bytes::Bytes) -> Result<(), StorageError> {
         self.0.set(key, value).await
@@ -209,7 +205,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> AsyncWritableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncReadableWritableStorageTraits> AsyncReadableWritableStorageTraits
-    for StorageHandle<'_, TStorage>
+    for StorageHandle<TStorage>
 {
     async fn mutex(&self, key: &StoreKey) -> Result<AsyncStoreKeyMutex, StorageError> {
         self.0.mutex(key).await
diff --git a/src/storage/storage_transformer.rs b/src/storage/storage_transformer.rs
index ea1b8d55..10e792c4 100644
--- a/src/storage/storage_transformer.rs
+++ b/src/storage/storage_transformer.rs
@@ -59,60 +59,51 @@ pub trait StorageTransformerExtension: core::fmt::Debug + Send + Sync {
     fn create_metadata(&self) -> Option<Metadata>;
 
     /// Create a readable transformer.
-    fn create_readable_transformer<'a>(
-        &'a self,
-        storage: ReadableStorage<'a>,
-    ) -> ReadableStorage<'a>;
+    fn create_readable_transformer(self: Arc<Self>, storage: ReadableStorage) -> ReadableStorage;
 
     /// Create a writable transformer.
-    fn create_writable_transformer<'a>(
-        &'a self,
-        storage: WritableStorage<'a>,
-    ) -> WritableStorage<'a>;
+    fn create_writable_transformer(self: Arc<Self>, storage: WritableStorage) -> WritableStorage;
 
     /// Create a readable and writable transformer.
-    fn create_readable_writable_transformer<'a>(
-        &'a self,
-        storage: ReadableWritableStorage<'a>,
-    ) -> ReadableWritableStorage<'a>;
+    fn create_readable_writable_transformer(
+        self: Arc<Self>,
+        storage: ReadableWritableStorage,
+    ) -> ReadableWritableStorage;
 
     /// Create a listable transformer.
-    fn create_listable_transformer<'a>(
-        &'a self,
-        storage: ListableStorage<'a>,
-    ) -> ListableStorage<'a>;
+    fn create_listable_transformer(self: Arc<Self>, storage: ListableStorage) -> ListableStorage;
 
     /// Create a readable and listable transformer.
-    fn create_readable_listable_transformer<'a>(
-        &'a self,
-        storage: ReadableListableStorage<'a>,
-    ) -> ReadableListableStorage<'a>;
+    fn create_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: ReadableListableStorage,
+    ) -> ReadableListableStorage;
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable transformer.
-    fn create_async_readable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableStorage<'a>,
-    ) -> AsyncReadableStorage<'a>;
+    fn create_async_readable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableStorage,
+    ) -> AsyncReadableStorage;
 
     #[cfg(feature = "async")]
     /// Create an asynchronous writable transformer.
-    fn create_async_writable_transformer<'a>(
-        &'a self,
-        storage: AsyncWritableStorage<'a>,
-    ) -> AsyncWritableStorage<'a>;
+    fn create_async_writable_transformer(
+        self: Arc<Self>,
+        storage: AsyncWritableStorage,
+    ) -> AsyncWritableStorage;
 
     #[cfg(feature = "async")]
     /// Create an asynchronous listable transformer.
-    fn create_async_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncListableStorage<'a>,
-    ) -> AsyncListableStorage<'a>;
+    fn create_async_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncListableStorage,
+    ) -> AsyncListableStorage;
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable and listable transformer.
-    fn create_async_readable_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableListableStorage<'a>,
-    ) -> AsyncReadableListableStorage<'a>;
+    fn create_async_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableListableStorage,
+    ) -> AsyncReadableListableStorage;
 }
diff --git a/src/storage/storage_transformer/performance_metrics.rs b/src/storage/storage_transformer/performance_metrics.rs
index 458d7b5d..19995240 100644
--- a/src/storage/storage_transformer/performance_metrics.rs
+++ b/src/storage/storage_transformer/performance_metrics.rs
@@ -70,8 +70,8 @@ impl PerformanceMetricsStorageTransformer {
         self.locks.load(Ordering::Relaxed)
     }
 
-    fn create_transformer<TStorage: ?Sized>(
-        &self,
+    fn create_transformer<TStorage: ?Sized + 'static>(
+        self: Arc<Self>,
         storage: Arc<TStorage>,
     ) -> Arc<PerformanceMetricsStorageTransformerImpl<TStorage>> {
         Arc::new(PerformanceMetricsStorageTransformerImpl {
@@ -87,86 +87,77 @@ impl StorageTransformerExtension for PerformanceMetricsStorageTransformer {
         None
     }
 
-    fn create_readable_transformer<'a>(
-        &'a self,
-        storage: ReadableStorage<'a>,
-    ) -> ReadableStorage<'a> {
+    fn create_readable_transformer(self: Arc<Self>, storage: ReadableStorage) -> ReadableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_writable_transformer<'a>(
-        &'a self,
-        storage: WritableStorage<'a>,
-    ) -> WritableStorage<'a> {
+    fn create_writable_transformer(self: Arc<Self>, storage: WritableStorage) -> WritableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_readable_writable_transformer<'a>(
-        &'a self,
-        storage: ReadableWritableStorage<'a>,
-    ) -> ReadableWritableStorage<'a> {
+    fn create_readable_writable_transformer(
+        self: Arc<Self>,
+        storage: ReadableWritableStorage,
+    ) -> ReadableWritableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_listable_transformer<'a>(
-        &'a self,
-        storage: ListableStorage<'a>,
-    ) -> ListableStorage<'a> {
+    fn create_listable_transformer(self: Arc<Self>, storage: ListableStorage) -> ListableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_readable_listable_transformer<'a>(
-        &'a self,
-        storage: ReadableListableStorage<'a>,
-    ) -> ReadableListableStorage<'a> {
+    fn create_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: ReadableListableStorage,
+    ) -> ReadableListableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable transformer.
-    fn create_async_readable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableStorage<'a>,
-    ) -> AsyncReadableStorage<'a> {
+    fn create_async_readable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableStorage,
+    ) -> AsyncReadableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous writable transformer.
-    fn create_async_writable_transformer<'a>(
-        &'a self,
-        storage: AsyncWritableStorage<'a>,
-    ) -> AsyncWritableStorage<'a> {
+    fn create_async_writable_transformer(
+        self: Arc<Self>,
+        storage: AsyncWritableStorage,
+    ) -> AsyncWritableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous listable transformer.
-    fn create_async_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncListableStorage<'a>,
-    ) -> AsyncListableStorage<'a> {
+    fn create_async_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncListableStorage,
+    ) -> AsyncListableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable and listable transformer.
-    fn create_async_readable_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableListableStorage<'a>,
-    ) -> AsyncReadableListableStorage<'a> {
+    fn create_async_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableListableStorage,
+    ) -> AsyncReadableListableStorage {
         self.create_transformer(storage)
     }
 }
 
 #[derive(Debug)]
-struct PerformanceMetricsStorageTransformerImpl<'a, TStorage: ?Sized> {
+struct PerformanceMetricsStorageTransformerImpl<TStorage: ?Sized + 'static> {
     storage: Arc<TStorage>,
-    transformer: &'a PerformanceMetricsStorageTransformer,
+    transformer: Arc<PerformanceMetricsStorageTransformer>,
 }
 
 impl<TStorage: ?Sized + ReadableStorageTraits> ReadableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     fn get(&self, key: &StoreKey) -> Result<MaybeBytes, StorageError> {
         let value = self.storage.get(key);
@@ -230,7 +221,7 @@ impl<TStorage: ?Sized + ReadableStorageTraits> ReadableStorageTraits
 }
 
 impl<TStorage: ?Sized + ListableStorageTraits> ListableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     fn list(&self) -> Result<StoreKeys, StorageError> {
         self.storage.list()
@@ -246,7 +237,7 @@ impl<TStorage: ?Sized + ListableStorageTraits> ListableStorageTraits
 }
 
 impl<TStorage: ?Sized + WritableStorageTraits> WritableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     fn set(&self, key: &StoreKey, value: &[u8]) -> Result<(), StorageError> {
         self.transformer
@@ -287,7 +278,7 @@ impl<TStorage: ?Sized + WritableStorageTraits> WritableStorageTraits
 }
 
 impl<TStorage: ?Sized + ReadableWritableStorageTraits> ReadableWritableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     fn mutex(&self, key: &StoreKey) -> Result<StoreKeyMutex, StorageError> {
         self.transformer.locks.fetch_add(1, Ordering::Relaxed);
@@ -298,7 +289,7 @@ impl<TStorage: ?Sized + ReadableWritableStorageTraits> ReadableWritableStorageTr
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncReadableStorageTraits> AsyncReadableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     async fn get(&self, key: &StoreKey) -> Result<MaybeBytes, StorageError> {
         let value = self.storage.get(key).await;
@@ -367,7 +358,7 @@ impl<TStorage: ?Sized + AsyncReadableStorageTraits> AsyncReadableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncListableStorageTraits> AsyncListableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     async fn list(&self) -> Result<StoreKeys, StorageError> {
         self.storage.list().await
@@ -385,7 +376,7 @@ impl<TStorage: ?Sized + AsyncListableStorageTraits> AsyncListableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncWritableStorageTraits> AsyncWritableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     async fn set(&self, key: &StoreKey, value: bytes::Bytes) -> Result<(), StorageError> {
         self.transformer
@@ -428,7 +419,7 @@ impl<TStorage: ?Sized + AsyncWritableStorageTraits> AsyncWritableStorageTraits
 #[cfg(feature = "async")]
 #[async_trait::async_trait]
 impl<TStorage: ?Sized + AsyncReadableWritableStorageTraits> AsyncReadableWritableStorageTraits
-    for PerformanceMetricsStorageTransformerImpl<'_, TStorage>
+    for PerformanceMetricsStorageTransformerImpl<TStorage>
 {
     async fn mutex(&self, key: &StoreKey) -> Result<AsyncStoreKeyMutex, StorageError> {
         self.transformer.locks.fetch_add(1, Ordering::Relaxed);
diff --git a/src/storage/storage_transformer/storage_transformer_chain.rs b/src/storage/storage_transformer/storage_transformer_chain.rs
index 436d6930..a37ada3a 100644
--- a/src/storage/storage_transformer/storage_transformer_chain.rs
+++ b/src/storage/storage_transformer/storage_transformer_chain.rs
@@ -55,104 +55,107 @@ impl StorageTransformerChain {
 
 impl StorageTransformerChain {
     /// Create a readable storage transformer.
-    pub fn create_readable_transformer<'a>(
-        &'a self,
-        mut storage: ReadableStorage<'a>,
-    ) -> ReadableStorage<'a> {
+    pub fn create_readable_transformer(&self, mut storage: ReadableStorage) -> ReadableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_readable_transformer(storage);
+            storage = transformer.clone().create_readable_transformer(storage);
         }
         storage
     }
 
     /// Create a writable storage transformer.
-    pub fn create_writable_transformer<'a>(
-        &'a self,
-        mut storage: WritableStorage<'a>,
-    ) -> WritableStorage<'a> {
+    pub fn create_writable_transformer(&self, mut storage: WritableStorage) -> WritableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_writable_transformer(storage);
+            storage = transformer.clone().create_writable_transformer(storage);
         }
         storage
     }
 
     /// Create a readable and writable storage transformer.
-    pub fn create_readable_writable_transformer<'a>(
-        &'a self,
-        mut storage: ReadableWritableStorage<'a>,
-    ) -> ReadableWritableStorage<'a> {
+    pub fn create_readable_writable_transformer(
+        &self,
+        mut storage: ReadableWritableStorage,
+    ) -> ReadableWritableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_readable_writable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_readable_writable_transformer(storage);
         }
         storage
     }
 
     /// Create a listable storage transformer.
-    pub fn create_listable_transformer<'a>(
-        &'a self,
-        mut storage: ListableStorage<'a>,
-    ) -> ListableStorage<'a> {
+    pub fn create_listable_transformer(&self, mut storage: ListableStorage) -> ListableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_listable_transformer(storage);
+            storage = transformer.clone().create_listable_transformer(storage);
         }
         storage
     }
 
     /// Create a readable and listable storage transformer.
-    pub fn create_readable_listable_transformer<'a>(
-        &'a self,
-        mut storage: ReadableListableStorage<'a>,
-    ) -> ReadableListableStorage<'a> {
+    pub fn create_readable_listable_transformer(
+        &self,
+        mut storage: ReadableListableStorage,
+    ) -> ReadableListableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_readable_listable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_readable_listable_transformer(storage);
         }
         storage
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable storage transformer.
-    pub fn create_async_readable_transformer<'a>(
-        &'a self,
-        mut storage: AsyncReadableStorage<'a>,
-    ) -> AsyncReadableStorage<'a> {
+    pub fn create_async_readable_transformer(
+        &self,
+        mut storage: AsyncReadableStorage,
+    ) -> AsyncReadableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_async_readable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_async_readable_transformer(storage);
         }
         storage
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous writable storage transformer.
-    pub fn create_async_writable_transformer<'a>(
-        &'a self,
-        mut storage: AsyncWritableStorage<'a>,
-    ) -> AsyncWritableStorage<'a> {
+    pub fn create_async_writable_transformer(
+        &self,
+        mut storage: AsyncWritableStorage,
+    ) -> AsyncWritableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_async_writable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_async_writable_transformer(storage);
         }
         storage
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous listable storage transformer.
-    pub fn create_async_listable_transformer<'a>(
-        &'a self,
-        mut storage: AsyncListableStorage<'a>,
-    ) -> AsyncListableStorage<'a> {
+    pub fn create_async_listable_transformer(
+        &self,
+        mut storage: AsyncListableStorage,
+    ) -> AsyncListableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_async_listable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_async_listable_transformer(storage);
         }
         storage
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable listable storage transformer.
-    pub fn create_async_readable_listable_transformer<'a>(
-        &'a self,
-        mut storage: AsyncReadableListableStorage<'a>,
-    ) -> AsyncReadableListableStorage<'a> {
+    pub fn create_async_readable_listable_transformer(
+        &self,
+        mut storage: AsyncReadableListableStorage,
+    ) -> AsyncReadableListableStorage {
         for transformer in &self.0 {
-            storage = transformer.create_async_readable_listable_transformer(storage);
+            storage = transformer
+                .clone()
+                .create_async_readable_listable_transformer(storage);
         }
         storage
     }
diff --git a/src/storage/storage_transformer/usage_log.rs b/src/storage/storage_transformer/usage_log.rs
index 76f75835..cc496e7c 100644
--- a/src/storage/storage_transformer/usage_log.rs
+++ b/src/storage/storage_transformer/usage_log.rs
@@ -44,9 +44,9 @@ use super::StorageTransformerExtension;
 ///     std::io::stdout(),
 ///     //    )
 /// ));
-/// let usage_log = UsageLogStorageTransformer::new(log_writer, || {
+/// let usage_log = Arc::new(UsageLogStorageTransformer::new(log_writer, || {
 ///     chrono::Utc::now().format("[%T%.3f] ").to_string()
-/// });
+/// }));
 /// let store = usage_log.create_readable_writable_transformer(store);
 /// ````
 ///
@@ -101,65 +101,65 @@ impl StorageTransformerExtension for UsageLogStorageTransformer {
         None
     }
 
-    fn create_readable_transformer<'a>(&self, storage: ReadableStorage<'a>) -> ReadableStorage<'a> {
+    fn create_readable_transformer(self: Arc<Self>, storage: ReadableStorage) -> ReadableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_readable_writable_transformer<'a>(
-        &'a self,
-        storage: ReadableWritableStorage<'a>,
-    ) -> ReadableWritableStorage<'a> {
+    fn create_readable_writable_transformer(
+        self: Arc<Self>,
+        storage: ReadableWritableStorage,
+    ) -> ReadableWritableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_writable_transformer<'a>(&self, storage: WritableStorage<'a>) -> WritableStorage<'a> {
+    fn create_writable_transformer(self: Arc<Self>, storage: WritableStorage) -> WritableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_listable_transformer<'a>(&self, storage: ListableStorage<'a>) -> ListableStorage<'a> {
+    fn create_listable_transformer(self: Arc<Self>, storage: ListableStorage) -> ListableStorage {
         self.create_transformer(storage)
     }
 
-    fn create_readable_listable_transformer<'a>(
-        &self,
-        storage: ReadableListableStorage<'a>,
-    ) -> ReadableListableStorage<'a> {
+    fn create_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: ReadableListableStorage,
+    ) -> ReadableListableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable transformer.
-    fn create_async_readable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableStorage<'a>,
-    ) -> AsyncReadableStorage<'a> {
+    fn create_async_readable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableStorage,
+    ) -> AsyncReadableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous writable transformer.
-    fn create_async_writable_transformer<'a>(
-        &'a self,
-        storage: AsyncWritableStorage<'a>,
-    ) -> AsyncWritableStorage<'a> {
+    fn create_async_writable_transformer(
+        self: Arc<Self>,
+        storage: AsyncWritableStorage,
+    ) -> AsyncWritableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous listable transformer.
-    fn create_async_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncListableStorage<'a>,
-    ) -> AsyncListableStorage<'a> {
+    fn create_async_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncListableStorage,
+    ) -> AsyncListableStorage {
         self.create_transformer(storage)
     }
 
     #[cfg(feature = "async")]
     /// Create an asynchronous readable and listable transformer.
-    fn create_async_readable_listable_transformer<'a>(
-        &'a self,
-        storage: AsyncReadableListableStorage<'a>,
-    ) -> AsyncReadableListableStorage<'a> {
+    fn create_async_readable_listable_transformer(
+        self: Arc<Self>,
+        storage: AsyncReadableListableStorage,
+    ) -> AsyncReadableListableStorage {
         self.create_transformer(storage)
     }
 }