feature/split_async_sync

Assets/PlayModeTests/CombinedDataTransformTests.cs

@@ -1,7 +1,7 @@
 using System.Collections;
 using System.Linq;
 using Cysharp.Threading.Tasks;
-using LocalStorage.Providers;
+using LocalStorage.DataTransform;
 using NUnit.Framework;
 using UnityEngine.TestTools;
 using static LocalStorage.PlayModeTests.Constants.Instances;

Assets/PlayModeTests/Constants.cs

@@ -3,7 +3,7 @@
 using System.Security.Cryptography;
 using LocalStorage.Compression;
 using LocalStorage.Encryption;
-using LocalStorage.Providers;
+using LocalStorage.Serialization;
 using UnityEngine;
 
 namespace LocalStorage.PlayModeTests

Assets/PlayModeTests/DataTransformSerializationProviderTests.cs

@@ -2,7 +2,7 @@
 using System.Collections;
 using System.Linq;
 using Cysharp.Threading.Tasks;
-using LocalStorage.Providers;
+using LocalStorage.Serialization;
 using NUnit.Framework;
 using UnityEngine.TestTools;
 using static LocalStorage.PlayModeTests.Constants.Instances;

Assets/PlayModeTests/FileStorageTests.cs

@@ -2,7 +2,7 @@
 using System.Collections;
 using System.Linq;
 using Cysharp.Threading.Tasks;
-using LocalStorage.Providers;
+using LocalStorage.Serialization;
 using NUnit.Framework;
 using UnityEngine.TestTools;
 using static LocalStorage.PlayModeTests.Constants.Instances;

Packages/LocalStorage/README.md

@@ -164,12 +164,13 @@ IDataTransform customDataTransform = new CustomDataTransform();
 IDataTransform multipleCombinedDataTransform =
     new CombinedDataTransform(customDataTransform, combinedDataTransform);
 ```
-## Generic storage usage
-There are generic implementations and interfaces of storage classes:
-- `IFileStorage<TSerialization>`
-- `IPlayerPrefsStorage<TSerialization>`
+## Sync/async API
+All interfaces come in 3 variants:
+- Sync API
+- Async API
+- Both sync and async
 
-Can be used with `DI containers` to bind multiple implementations.
+Implementations that depends on mentioned interfaces have same 3 variants, e.g. `FileStorage` for both sync and async API, `FileStorageSync` for sync API only and `FileStorageAsync` for async API only.
 
 # License
 The software released under the terms of the [MIT license](./LICENSE.md).

Packages/LocalStorage/Runtime/Providers/CombinedDataTransform.cs → Packages/LocalStorage/Runtime/DataTransform/CombinedDataTransform.cs

@@ -1,12 +1,12 @@
 using System;
+using UnityEngine.Scripting;
 #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
 using Cysharp.Threading.Tasks;
 #else
 using System.Threading.Tasks;
 #endif
-using UnityEngine.Scripting;
 
-namespace LocalStorage.Providers
+namespace LocalStorage.DataTransform
 {
     public class CombinedDataTransform : IDataTransform
     {

Packages/LocalStorage/Runtime/DataTransform/CombinedDataTransformAsync.cs

@@ -0,0 +1,47 @@
+using System;
+#if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+using Cysharp.Threading.Tasks;
+#else
+using System.Threading.Tasks;
+#endif
+using UnityEngine.Scripting;
+
+namespace LocalStorage.DataTransform
+{
+    public class CombinedDataTransformAsync : IDataTransformAsync
+    {
+        private readonly IDataTransformAsync _firstTransform;
+        private readonly IDataTransformAsync _secondTransform;
+
+        [RequiredMember]
+        public CombinedDataTransformAsync(IDataTransformAsync firstTransform, IDataTransformAsync secondTransform)
+        {
+            _firstTransform = firstTransform ??
+                              throw new ArgumentNullException(nameof(firstTransform));
+            _secondTransform = secondTransform ??
+                               throw new ArgumentNullException(nameof(secondTransform));
+        }
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public UniTask<byte[]> ApplyAsync(byte[] data) =>
+            _firstTransform.ApplyAsync(data)
+                .ContinueWith(bytes => _secondTransform.ApplyAsync(bytes));
+        #else
+        public Task<byte[]> ApplyAsync(byte[] data) =>
+            _firstTransform.ApplyAsync(data)
+                .ContinueWith(task => _secondTransform.ApplyAsync(task.Result))
+                .Unwrap();
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public UniTask<byte[]> ReverseAsync(byte[] data) =>
+            _secondTransform.ReverseAsync(data)
+                .ContinueWith(bytes => _firstTransform.ReverseAsync(bytes));
+        #else
+        public Task<byte[]> ReverseAsync(byte[] data) =>
+            _secondTransform.ReverseAsync(data)
+                .ContinueWith(task => _firstTransform.ReverseAsync(task.Result))
+                .Unwrap();
+        #endif
+    }
+}

Packages/LocalStorage/Runtime/DataTransform/CombinedDataTransformSync.cs

@@ -0,0 +1,26 @@
+using System;
+using UnityEngine.Scripting;
+
+namespace LocalStorage.DataTransform
+{
+    public class CombinedDataTransformSync : IDataTransformSync
+    {
+        private readonly IDataTransformSync _firstTransform;
+        private readonly IDataTransformSync _secondTransform;
+
+        [RequiredMember]
+        public CombinedDataTransformSync(IDataTransformSync firstTransform, IDataTransformSync secondTransform)
+        {
+            _firstTransform = firstTransform ??
+                              throw new ArgumentNullException(nameof(firstTransform));
+            _secondTransform = secondTransform ??
+                               throw new ArgumentNullException(nameof(secondTransform));
+        }
+
+        public byte[] Apply(byte[] data) =>
+            _secondTransform.Apply(_firstTransform.Apply(data));
+
+        public byte[] Reverse(byte[] data) =>
+            _firstTransform.Reverse(_secondTransform.Reverse(data));
+    }
+}

Packages/LocalStorage/Runtime/Extensions.cs

@@ -0,0 +1,71 @@
+namespace LocalStorage
+{
+    public static class Extensions
+    {
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask<byte[]> SerializeFakeAsync<T>(
+            this ISerializationProviderSync provider, T data) =>
+            Cysharp.Threading.Tasks.UniTask.FromResult<byte[]>(provider.Serialize(data));
+        #else
+        public static System.Threading.Tasks.Task<byte[]> SerializeFakeAsync<T>(
+            this ISerializationProviderSync provider, T data) =>
+            System.Threading.Tasks.Task.FromResult<byte[]>(provider.Serialize(data));
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask<T> DeserializeFakeAsync<T>(
+            this ISerializationProviderSync provider, byte[] data) =>
+            Cysharp.Threading.Tasks.UniTask.FromResult<T>(provider.Deserialize<T>(data));
+        #else
+        public static System.Threading.Tasks.Task<T> DeserializeFakeAsync<T>(this ISerializationProviderSync provider,
+            byte[] data) =>
+            System.Threading.Tasks.Task.FromResult<T>(provider.Deserialize<T>(data));
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask WriteFakeAsync(this IFileProviderSync provider, byte[] output,
+            string fileName)
+        {
+            provider.Write(output, fileName);
+            return Cysharp.Threading.Tasks.UniTask.CompletedTask;
+        }
+        #else
+        public static System.Threading.Tasks.Task WriteFakeAsync(this IFileProviderSync provider, byte[] output,
+            string fileName)
+        {
+            provider.Write(output, fileName);
+            return System.Threading.Tasks.Task.CompletedTask;
+        }
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask<byte[]> ReadFakeAsync(this IFileProviderSync provider,
+            string fileName) =>
+            Cysharp.Threading.Tasks.UniTask.FromResult<byte[]>(provider.Read(fileName));
+        #else
+        public static System.Threading.Tasks.Task<byte[]> ReadFakeAsync(this IFileProviderSync provider,
+            string fileName) =>
+            System.Threading.Tasks.Task.FromResult<byte[]>(provider.Read(fileName));
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask<byte[]> ApplyFakeAsync(this IDataTransformSync dataTransform,
+            byte[] data) =>
+            Cysharp.Threading.Tasks.UniTask.FromResult<byte[]>(dataTransform.Apply(data));
+        #else
+        public static System.Threading.Tasks.Task<byte[]> ApplyFakeAsync(this IDataTransformSync dataTransform,
+            byte[] data) =>
+            System.Threading.Tasks.Task.FromResult<byte[]>(dataTransform.Apply(data));
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public static Cysharp.Threading.Tasks.UniTask<byte[]> ReverseFakeAsync(this IDataTransformSync dataTransform,
+            byte[] data) =>
+            Cysharp.Threading.Tasks.UniTask.FromResult<byte[]>(dataTransform.Reverse(data));
+        #else
+        public static System.Threading.Tasks.Task<byte[]> ReverseFakeAsync(this IDataTransformSync dataTransform,
+            byte[] data) =>
+            System.Threading.Tasks.Task.FromResult<byte[]>(dataTransform.Reverse(data));
+        #endif
+    }
+}

Packages/LocalStorage/Runtime/Providers/FileProvider.cs → Packages/LocalStorage/Runtime/FileProvider.cs

@@ -1,13 +1,13 @@
 using System.IO;
+using UnityEngine;
+using UnityEngine.Scripting;
 #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
 using Cysharp.Threading.Tasks;
 #else
 using System.Threading.Tasks;
 #endif
-using UnityEngine;
-using UnityEngine.Scripting;
 
-namespace LocalStorage.Providers
+namespace LocalStorage
 {
     public class FileProvider : IFileProvider
     {

Packages/LocalStorage/Runtime/FileStorage.cs

@@ -27,6 +27,10 @@ public void Save<TData>(TData data, string fileName) =>
             _fileProvider.Write(_serializationProvider.Serialize(data),
                 GetFilePath(fileName));
 
+        public TData Load<TData>(string fileName) =>
+            _serializationProvider
+                .Deserialize<TData>(_fileProvider.Read(GetFilePath(fileName)));
+
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         public UniTask SaveAsync<TData>(TData data, string fileName) =>
             _serializationProvider.SerializeAsync(data)
@@ -39,21 +43,17 @@ public Task SaveAsync<TData>(TData data, string fileName) =>
                     _fileProvider.WriteAsync(task.Result, GetFilePath(fileName)));
         #endif
 
-        public TData Load<TData>(string fileName) =>
-            _serializationProvider
-                .Deserialize<TData>(_fileProvider.Read(GetFilePath(fileName)));
-
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         public UniTask<TData> LoadAsync<TData>(string fileName)
         {
             return _fileProvider.ReadAsync(GetFilePath(fileName))
-                .ContinueWith(bytes => _serializationProvider.Deserialize<TData>(bytes));
+                .ContinueWith(bytes => _serializationProvider.DeserializeAsync<TData>(bytes));
         }
         #else
         public Task<TData> LoadAsync<TData>(string fileName)
         {
             return _fileProvider.ReadAsync(GetFilePath(fileName))
-                .ContinueWith(task => _serializationProvider.Deserialize<TData>(task.Result));
+                .ContinueWith(task => _serializationProvider.DeserializeAsync<TData>(task.Result)).Unwrap();
         }
         #endif
 
@@ -66,14 +66,4 @@ public string GetFilePath(string fileName) =>
         public bool FileExists(string fileName) =>
             _fileProvider.FileExists(fileName);
     }
-
-    public class FileStorage<TSerialization> : FileStorage, IFileStorage<TSerialization>
-        where TSerialization : ISerializationProvider
-    {
-        [RequiredMember]
-        public FileStorage(TSerialization serializationProvider, IFileProvider fileProvider) : base(
-            serializationProvider, fileProvider)
-        {
-        }
-    }
 }

Packages/LocalStorage/Runtime/FileStorageAsync.cs

@@ -0,0 +1,61 @@
+using System;
+#if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+using Cysharp.Threading.Tasks;
+#else
+using System.Threading.Tasks;
+#endif
+using UnityEngine.Scripting;
+
+namespace LocalStorage
+{
+    public class FileStorageAsync : IFileStorageAsync
+    {
+        private readonly ISerializationProviderAsync _serializationProvider;
+        private readonly IFileProviderAsync _fileProvider;
+
+        [RequiredMember]
+        public FileStorageAsync(ISerializationProviderAsync serializationProvider,
+            IFileProviderAsync fileProvider)
+        {
+            _serializationProvider = serializationProvider ??
+                                     throw new ArgumentNullException(nameof(serializationProvider));
+            _fileProvider = fileProvider ??
+                            throw new ArgumentNullException(nameof(fileProvider));
+        }
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public UniTask SaveAsync<TData>(TData data, string fileName) =>
+            _serializationProvider.SerializeAsync(data)
+                .ContinueWith(bytes =>
+                    _fileProvider.WriteAsync(bytes, GetFilePath(fileName)));
+        #else
+        public Task SaveAsync<TData>(TData data, string fileName) =>
+            _serializationProvider.SerializeAsync(data)
+                .ContinueWith(task =>
+                    _fileProvider.WriteAsync(task.Result, GetFilePath(fileName)));
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        public UniTask<TData> LoadAsync<TData>(string fileName)
+        {
+            return _fileProvider.ReadAsync(GetFilePath(fileName))
+                .ContinueWith(bytes => _serializationProvider.DeserializeAsync<TData>(bytes));
+        }
+        #else
+        public Task<TData> LoadAsync<TData>(string fileName)
+        {
+            return _fileProvider.ReadAsync(GetFilePath(fileName))
+                .ContinueWith(task => _serializationProvider.DeserializeAsync<TData>(task.Result)).Unwrap();
+        }
+        #endif
+
+        public bool Delete(string fileName) =>
+            _fileProvider.Delete(fileName);
+
+        public string GetFilePath(string fileName) =>
+            _fileProvider.GetFilePath(fileName);
+
+        public bool FileExists(string fileName) =>
+            _fileProvider.FileExists(fileName);
+    }
+}