From 08ff087f420c0c7fbc9d5cff18f6bc5ccd14a93f Mon Sep 17 00:00:00 2001
From: Reece Wilson <code@reece.sx>
Date: Tue, 16 Aug 2022 08:41:32 +0100
Subject: [PATCH] [+] AuAsync::PromiseCallback<Resul_t, Error_t> [*] Adjust
 compression defaults

---
 Include/Aurora/Async/IPCPromises.hpp          | 93 ++++++++++++++++++-
 .../Aurora/Compression/CompressionInfo.hpp    |  4 +-
 2 files changed, 90 insertions(+), 7 deletions(-)

diff --git a/Include/Aurora/Async/IPCPromises.hpp b/Include/Aurora/Async/IPCPromises.hpp
index f9801877..dff7d3d7 100644
--- a/Include/Aurora/Async/IPCPromises.hpp
+++ b/Include/Aurora/Async/IPCPromises.hpp
@@ -7,6 +7,11 @@
 ***/
 #pragma once
 
+struct AuNullS
+{
+    AuUInt8 null;
+};
+
 namespace Aurora::Async
 {
     struct IPromiseCompleter
@@ -50,6 +55,79 @@ namespace Aurora::Async
         OnSuccess_f onSuccess_;
     };
 
+    template <class SuccessValue_t, class ErrorValue_t = AuNullS>
+    struct PromiseCallback : IPromiseFailure, IPromiseComplete
+    {
+        inline PromiseCallback()
+        {}
+
+        inline virtual void OnFailure(void *in) override
+        {
+            this->OnFailure(AuReinterpretCast<ErrorValue_t *>(in));
+        }
+
+        inline virtual void OnSuccess(void *in) override
+        {
+            this->OnSuccess(AuReinterpretCast<ErrorValue_t *>(in));
+        }
+
+        virtual void OnFailure(ErrorValue_t *in) = 0;
+        virtual void OnSuccess(SuccessValue_t *in) = 0;
+    };
+
+    template <class SuccessValue_t, class ErrorValue_t>
+    struct PromiseCallbackFunctional : PromiseCallback<SuccessValue_t, ErrorValue_t>, AuEnableSharedFromThis<PromiseCallbackFunctional<SuccessValue_t, ErrorValue_t>>
+    {
+        using OnSuccess_f = AuFunction<void(const AuSPtr<SuccessValue_t> &)>;
+        using OnFailure_f = AuFunction<void(const AuSPtr<ErrorValue_t> &)>;
+
+        inline PromiseCallbackFunctional(OnSuccess_f onSuccess,
+                                         OnFailure_f onFailure) :
+            onSuccess(onSuccess),
+            onFailure(onFailure)
+        {
+
+        }
+
+        inline PromiseCallbackFunctional()
+        {
+
+        }
+
+        virtual void OnFailure(ErrorValue_t *in) override
+        {
+            if (this->onFailure)
+            {
+                if (!in)
+                {
+                    this->onFailure({});
+                }
+                else
+                {
+                    this->onFailure(AuSPtr<ErrorValue_t>(AuSharedFromThis(), in));
+                }
+            }
+        }
+
+        virtual void OnSuccess(SuccessValue_t *in) override
+        {
+            if (this->onSuccess)
+            {
+                if (!in)
+                {
+                    this->onSuccess({});
+                }
+                else
+                {
+                    this->onSuccess(AuSPtr<SuccessValue_t>(AuSharedFromThis(), in));
+                }
+            }
+        }
+
+        OnFailure_f onFailure;
+        OnSuccess_f onSuccess;
+    };
+
     template <class ErrorValue_t>
     struct PromiseFailTmpl : IPromiseFailure
     {
@@ -169,6 +247,8 @@ namespace Aurora::Async
         using FunctionalFail_f = typename FunctionalFail_t::OnFailure_f;
         using FunctionalDelegate_f = typename FunctionalCall_t::OnDelegate_f;
 
+        inline AuSPtr<This_t> SetCallback(const AuSPtr<PromiseCallback<SuccessValue_t, ErrorValue_t>> &callbacks);
+
         inline AuSPtr<This_t> OnSuccessFunctional(const FunctionalResponse_f &in);
         inline AuSPtr<This_t> OnSuccessCallback(const AuSPtr<IPromiseComplete> &in);
 
@@ -501,6 +581,14 @@ namespace Aurora::Async
         return BeginWorkEx(AuUnsafeRaiiToShared(&this->delegateFunctional_), worker);
     }
 
+    template<class SuccessValue_t, class ErrorValue_t>
+    inline AuSPtr<Promise<SuccessValue_t, ErrorValue_t>> Promise<SuccessValue_t, ErrorValue_t>::SetCallback(const AuSPtr<PromiseCallback<SuccessValue_t, ErrorValue_t>> &callbacks)
+    {
+        this->OnSuccessCallback(callbacks);
+        this->OnFailureCallback(callbacks);
+        return AuSPtr<Promise>(AuSharedFromThis());
+    }
+
     template<class SuccessValue_t, class ErrorValue_t>
     inline AuSPtr<Promise<SuccessValue_t, ErrorValue_t>> Promise<SuccessValue_t, ErrorValue_t>::OnSuccessFunctional(const FunctionalResponse_f &in)
     {
@@ -621,11 +709,6 @@ namespace Aurora::Async
     }
 }
 
-struct AuNullS
-{
-    AuUInt8 null;
-};
-
 using AuNullPromise = Aurora::Async::Promise<AuNullS, AuNullS>;
 
 template <class Out_t, class Error_t = AuNullS>
diff --git a/Include/Aurora/Compression/CompressionInfo.hpp b/Include/Aurora/Compression/CompressionInfo.hpp
index d5972ff7..8ca875ec 100644
--- a/Include/Aurora/Compression/CompressionInfo.hpp
+++ b/Include/Aurora/Compression/CompressionInfo.hpp
@@ -69,7 +69,7 @@ namespace Aurora::Compression
          * @brief Internal output buffer size. 
          *        Internal swap page is undefined.
         */
-        AuUInt32 internalStreamSize {4096};
+        AuUInt32 internalStreamSize { 10 * 4096 };
 
         AuUInt8 threads {1};
 
@@ -98,7 +98,7 @@ namespace Aurora::Compression
         /**
          * @brief Internal output buffer size. Internal swap page is undefined.
         */
-        AuUInt32 internalStreamSize {4096};
+        AuUInt32 internalStreamSize { 10 * 4096 };
         
         /**
          * @brief Flag for headerless decompression streams