AComplexFutureOperation.h

#pragma once
 
#include "AFuture.h"
#include "AAsyncHolder.h"
 
template<typename T>
class AComplexFutureOperation {
public:
    class NoValueException: AException {
    public:
        NoValueException(): AException("no value") {}
    };
 
    AComplexFutureOperation(): mFutureWeakReference(mFutureStrongReference.inner().weak()) {}
 
    ~AComplexFutureOperation() {
        AUI_ASSERTX(mFutureStrongReference.inner() == nullptr, "makeFuture() is not called. Please check docs");
        if (auto f = mFutureWeakReference.lock()) {
            if (!(*f)->hasResult()) {
                try {
                    throw NoValueException();
                } catch (...) {
                    (*f)->reportException();
                }
            }
        }
    }
 
    [[nodiscard]]
    AFuture<T> makeFuture() noexcept {
        auto r = std::move(mFutureStrongReference);
        AUI_ASSERT(mFutureStrongReference.inner() == nullptr);
        return r;
    }
 
    template<typename OtherT>
    AComplexFutureOperation& operator<<(AFuture<OtherT> rhs) {
        rhs.onError([weakRef = mFutureWeakReference](const AException& e) {
            if (auto f = weakRef.lock()) {
                if ((*f)->hasResult()) {
                    return;
                }
                try {
                    throw e;
                } catch (...) {
                    (*f)->reportException();
                }
            }
        });
        mAsyncHolder << std::move(rhs);
        return *this;
    }
 
    void supplyValue(T value) {
        if (auto l = mFutureWeakReference.lock()) {
            auto& inner = *l;
            std::unique_lock lock(inner->mutex);
            inner->value = std::move(value);
            inner->cv.notify_all();
            inner->notifyOnSuccessCallback(lock);
        }
    }
 
    void supplyException() {
        if (auto l = mFutureWeakReference.lock()) {
            auto& inner = *l;
            inner->reportException();
        }
    }
 
private:
    AFuture<T> mFutureStrongReference;
    AAsyncHolder mAsyncHolder;
 
    /*
     * Avoid holding a strong reference - we need to keep future cancellation on reference count exceeding
     * even while actual future execution.
     */
    _weak<typename AFuture<T>::Inner> mFutureWeakReference;
};