feat: split sync and async API into different interfaces

Assets/PlayModeTests/CombinedDataTransformTests.cs

@@ -22,7 +22,7 @@ public class CombinedDataTransformTests
 
         [Test]
         [TestCaseSource(nameof(_dataTransforms))]
-        public void DataTransform_ApplyReverse(IDataTransform dataTransform)
+        public void DataTransform_ApplyReverse(IDataTransformAsync dataTransform)
         {
             var applied = dataTransform.Apply(TestByteData);
             var result = dataTransform.Reverse(applied);
@@ -34,7 +34,7 @@ public void DataTransform_ApplyReverse(IDataTransform dataTransform)
         public IEnumerator DataTransform_ApplyReverseAsync()
             => UniTask.ToCoroutine(async () =>
             {
-                async UniTask Test(byte[] data, IDataTransform dataTransform)
+                async UniTask Test(byte[] data, IDataTransformAsync dataTransform)
                 {
                     var applied = await dataTransform.ApplyAsync(data);
                     var result = await dataTransform.ReverseAsync(applied);
@@ -44,7 +44,7 @@ async UniTask Test(byte[] data, IDataTransform dataTransform)
 
                 foreach (var serializationProvider in _dataTransforms
                     .Select(o => (object[]) o)
-                    .Select(objects => (IDataTransform) objects[0]))
+                    .Select(objects => (IDataTransformAsync) objects[0]))
                 {
                     await Test(TestByteData, serializationProvider);
                 }

Assets/PlayModeTests/Constants.cs

@@ -26,14 +26,14 @@ public EncryptionSettings()
             }
 
             public static readonly IEncryptionSettings Es = new EncryptionSettings();
-            public static readonly IDataTransform AesDT = new AesEncryptionDataTransform(Es);
-            public static readonly IDataTransform DeflateDT = new DeflateDataTransform();
-            public static readonly IDataTransform GZipDT = new GZipDataTransform();
+            public static readonly IDataTransformAsync AesDT = new AesEncryptionDataTransform(Es);
+            public static readonly IDataTransformAsync DeflateDT = new DeflateDataTransform();
+            public static readonly IDataTransformAsync GZipDT = new GZipDataTransform();
 
-            public static readonly ISerializationProvider UnityJsonSP
+            public static readonly ISerializationProviderAsync UnityJsonSP
                 = new UnityJsonSerializationProvider();
 
-            public static readonly IFileProvider FP = new FileProvider();
+            public static readonly IFileProviderAsync FP = new FileProvider();
         }
 
         public static class Data

Assets/PlayModeTests/DataTransformSerializationProviderTests.cs

@@ -30,8 +30,8 @@ public class DataTransformSerializationProviderTests
 
         [Test]
         [TestCaseSource(nameof(_argumentNullExceptionCases))]
-        public void SerializationProvider_ThrowsArgumentNullException(ISerializationProvider serializationProvider,
-            IDataTransform dataTransform)
+        public void SerializationProvider_ThrowsArgumentNullException(ISerializationProviderAsync serializationProvider,
+            IDataTransformAsync dataTransform)
         {
             Assert.Throws<ArgumentNullException>(() =>
             {
@@ -41,7 +41,7 @@ public void SerializationProvider_ThrowsArgumentNullException(ISerializationProv
 
         [Test]
         [TestCaseSource(nameof(_serializationProviders))]
-        public void SerializationProvider_SerializeDeserialize(ISerializationProvider serializationProvider)
+        public void SerializationProvider_SerializeDeserialize(ISerializationProviderAsync serializationProvider)
         {
             void Test<T>(T data)
             {
@@ -59,7 +59,7 @@ void Test<T>(T data)
         public IEnumerator SerializationProvider_SerializeDeserializeAsync()
             => UniTask.ToCoroutine(async () =>
             {
-                async UniTask Test<T>(T data, ISerializationProvider serializationProvider)
+                async UniTask Test<T>(T data, ISerializationProviderAsync serializationProvider)
                 {
                     var serialized =await serializationProvider.SerializeAsync(data);
                     var deserialized = await serializationProvider.DeserializeAsync<T>(serialized);
@@ -69,7 +69,7 @@ async UniTask Test<T>(T data, ISerializationProvider serializationProvider)
 
                 foreach (var serializationProvider in _serializationProviders
                     .Select(o => (object[]) o)
-                    .Select(objects => (ISerializationProvider) objects[0]))
+                    .Select(objects => (ISerializationProviderAsync) objects[0]))
                 {
                     await Test(GenericDataVector, serializationProvider);
                     await Test(GenericDataStruct, serializationProvider);

Assets/PlayModeTests/FileStorageTests.cs

@@ -31,7 +31,7 @@ public class FileStorageTests
         [Test]
         [TestCaseSource(nameof(ArgumentNullExceptionCases))]
         public void Storage_ThrowsArgumentNullException(
-            ISerializationProvider serializationProvider, IFileProvider fileProvider)
+            ISerializationProviderAsync serializationProvider, IFileProviderAsync fileProvider)
         {
             Assert.Throws<ArgumentNullException>(() =>
             {
@@ -41,7 +41,7 @@ public void Storage_ThrowsArgumentNullException(
 
         [Test]
         [TestCaseSource(nameof(StorageInstances))]
-        public void Storage_SaveLoad(IFileStorage storage)
+        public void Storage_SaveLoad(IFileStorageAsync storage)
         {
             //Can't use [TestCase] or [TestCaseSource]
             //because of IL2CPP AOT compilation
@@ -70,7 +70,7 @@ public IEnumerator Storage_SaveLoadAsync()
             {
                 //Can't use [TestCase] or [TestCaseSource]
                 //because of IL2CPP AOT compilation
-                async UniTask Test<T>(T data, IFileStorage storage)
+                async UniTask Test<T>(T data, IFileStorageAsync storage)
                 {
                     Setup.DeleteFile(FilePath);
 
@@ -89,7 +89,7 @@ async UniTask Test<T>(T data, IFileStorage storage)
 
                 foreach (var storage in StorageInstances
                     .Select(o => (object[]) o)
-                    .Select(objects => (IFileStorage) objects[0]))
+                    .Select(objects => (IFileStorageAsync) objects[0]))
                 {
                     await Test(GenericDataVector, storage);
                     await Test(GenericDataStruct, storage);

Assets/PlayModeTests/PlayerPrefsStorageTests.cs

@@ -11,7 +11,7 @@ namespace LocalStorage.PlayModeTests
     [TestFixture]
     public class PlayerPrefsStorageTests
     {
-        private static readonly IPlayerPrefsStorage Storage =
+        private static readonly IPlayerPrefsStorageAsync Storage =
             new PlayerPrefsStorage(UnityJsonSP, true);
 
         [SetUp]

Packages/LocalStorage/Runtime/Compression/DeflateDataTransform.cs

@@ -6,7 +6,7 @@
 
 namespace LocalStorage.Compression
 {
-    public class DeflateDataTransform : IDataTransform
+    public class DeflateDataTransform : IDataTransformAsync
     {
         public byte[] Apply(byte[] data)
         {

Packages/LocalStorage/Runtime/Compression/GZipDataTransform.cs

@@ -6,7 +6,7 @@
 
 namespace LocalStorage.Compression
 {
-    public class GZipDataTransform : IDataTransform
+    public class GZipDataTransform : IDataTransformAsync
     {
         public byte[] Apply(byte[] data)
         {

Packages/LocalStorage/Runtime/Encryption/AesEncryptionDataTransform.cs

@@ -8,7 +8,7 @@
 
 namespace LocalStorage.Encryption
 {
-    public class AesEncryptionDataTransform : IDataTransform
+    public class AesEncryptionDataTransform : IDataTransformAsync
     {
         private readonly IEncryptionSettings _encryptionSettings;
 

Packages/LocalStorage/Runtime/FileStorage.cs

@@ -8,14 +8,14 @@
 
 namespace LocalStorage
 {
-    public class FileStorage : IFileStorage
+    public class FileStorage : IFileStorageAsync
     {
-        private readonly ISerializationProvider _serializationProvider;
-        private readonly IFileProvider _fileProvider;
+        private readonly ISerializationProviderAsync _serializationProvider;
+        private readonly IFileProviderAsync _fileProvider;
 
         [RequiredMember]
-        public FileStorage(ISerializationProvider serializationProvider,
-            IFileProvider fileProvider)
+        public FileStorage(ISerializationProviderAsync serializationProvider,
+            IFileProviderAsync fileProvider)
         {
             _serializationProvider = serializationProvider ??
                                      throw new ArgumentNullException(nameof(serializationProvider));
@@ -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/IDataTransform.cs

@@ -10,14 +10,17 @@ public interface IDataTransform
     {
         byte[] Apply(byte[] data);
 
+        byte[] Reverse(byte[] data);
+    }
+
+    public interface IDataTransformAsync : IDataTransform
+    {
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<byte[]> ApplyAsync(byte[] data);
         #else
         Task<byte[]> ApplyAsync(byte[] data);
         #endif
 
-        byte[] Reverse(byte[] data);
-
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<byte[]> ReverseAsync(byte[] data);
         #else

Packages/LocalStorage/Runtime/IFileProvider.cs

@@ -10,24 +10,27 @@ public interface IFileProvider
     {
         void Write(byte[] output, string fileName);
 
+        byte[] Read(string fileName);
+
+        bool Delete(string fileName);
+
+        string GetFilePath(string fileName);
+
+        bool FileExists(string fileName);
+    }
+
+    public interface IFileProviderAsync : IFileProvider
+    {
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask WriteAsync(byte[] output, string fileName);
         #else
         Task WriteAsync(byte[] output, string fileName);
         #endif
 
-        byte[] Read(string fileName);
-
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<byte[]> ReadAsync(string fileName);
         #else
         Task<byte[]> ReadAsync(string fileName);
         #endif
-
-        bool Delete(string fileName);
-
-        string GetFilePath(string fileName);
-
-        bool FileExists(string fileName);
     }
 }

Packages/LocalStorage/Runtime/IFileStorage.cs

@@ -10,30 +10,27 @@ public interface IFileStorage
     {
         void Save<TData>(TData data, string fileName);
 
+        TData Load<TData>(string fileName);
+
+        bool Delete(string fileName);
+
+        string GetFilePath(string fileName);
+
+        bool FileExists(string fileName);
+    }
+
+    public interface IFileStorageAsync : IFileStorage
+    {
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask SaveAsync<TData>(TData data, string fileName);
         #else
         Task SaveAsync<TData>(TData data, string fileName);
         #endif
 
-        TData Load<TData>(string fileName);
-
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<TData> LoadAsync<TData>(string fileName);
         #else
         Task<TData> LoadAsync<TData>(string fileName);
         #endif
-
-        bool Delete(string fileName);
-
-        string GetFilePath(string fileName);
-
-        bool FileExists(string fileName);
-    }
-
-    public interface IFileStorage<TSerialization> : IFileStorage
-        where TSerialization : ISerializationProvider
-    {
-
     }
 }

Packages/LocalStorage/Runtime/IPlayerPrefsStorage.cs

@@ -9,44 +9,42 @@ namespace LocalStorage
     public interface IPlayerPrefsStorage
     {
         void SetData<T>(string key, T data);
-
-        T GetData<T>(string key);
 
-        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
-        UniTask SetDataAsync<T>(string key, T data);
-        #else
-        Task SetDataAsync<T>(string key, T data);
-        #endif
-
-        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
-        UniTask<T> GetDataAsync<T>(string key);
-        #else
-        Task<T> GetDataAsync<T>(string key);
-        #endif
+        T GetData<T>(string key);
 
         void SetFloat(string key, float value);
-        
+
         float GetFloat(string key);
-        
+
         void SetInt(string key, int value);
-        
+
         int GetInt(string key);
-        
+
         void SetString(string key, string value);
-        
+
         string GetString(string key);
-        
+
         bool HasKey(string key);
-        
+
         void Save();
-        
+
         void DeleteKey(string key);
-        
+
         void DeleteAll();
     }
 
-    public interface IPlayerPrefsStorage<TSerialization> : IPlayerPrefsStorage
-        where TSerialization : ISerializationProvider
+    public interface IPlayerPrefsStorageAsync : IPlayerPrefsStorage
     {
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        UniTask SetDataAsync<T>(string key, T data);
+        #else
+        Task SetDataAsync<T>(string key, T data);
+        #endif
+
+        #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
+        UniTask<T> GetDataAsync<T>(string key);
+        #else
+        Task<T> GetDataAsync<T>(string key);
+        #endif
     }
 }

Packages/LocalStorage/Runtime/ISerializationProvider.cs

@@ -10,14 +10,17 @@ public interface ISerializationProvider
     {
         byte[] Serialize<T>(T data);
 
+        T Deserialize<T>(byte[] data);
+    }
+
+    public interface ISerializationProviderAsync : ISerializationProvider
+    {
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<byte[]> SerializeAsync<T>(T data);
         #else
         Task<byte[]> SerializeAsync<T>(T data);
         #endif
 
-        T Deserialize<T>(byte[] data);
-
         #if !DISABLE_UNITASK_SUPPORT && UNITASK_SUPPORT
         UniTask<T> DeserializeAsync<T>(byte[] data);
         #else