promise.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/function.h"
#include "fl/stl/string.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/move.h"
#include "fl/stl/atomic.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace task {

struct Error {
    fl::string message;
 
    Error() FL_NOEXCEPT = default;
    Error(const fl::string& msg) FL_NOEXCEPT : message(msg) {}
    Error(const char* msg) FL_NOEXCEPT : message(msg) {}
    Error(fl::string&& msg) FL_NOEXCEPT : message(fl::move(msg)) {}
    bool is_empty() const FL_NOEXCEPT { return message.empty(); }
};
 
// Forward declaration for implementation
namespace detail {
    template<typename T>
    class PromiseImpl;
}

template<typename T>
class Promise {
public:
    static Promise<T> create() FL_NOEXCEPT {
        auto impl = fl::make_shared<detail::PromiseImpl<T>>();
        return Promise<T>(impl);
    }

    static Promise<T> resolve(const T& value) FL_NOEXCEPT {  // okay static in header
        auto p = create();
        p.complete_with_value(value);
        return p;
    }

    static Promise<T> resolve(T&& value) FL_NOEXCEPT {  // okay static in header
        auto p = create();
        p.complete_with_value(fl::move(value));
        return p;
    }

    static Promise<T> reject(const Error& error) FL_NOEXCEPT {  // okay static in header
        auto p = create();
        p.complete_with_error(error);
        return p;
    }

    static Promise<T> reject(const fl::string& error_message) FL_NOEXCEPT {  // okay static in header
        return reject(Error(error_message));
    }

    Promise() FL_NOEXCEPT : mImpl(nullptr) {}

    Promise(const Promise& other) = default;

    Promise(Promise&& other) FL_NOEXCEPT = default;

    Promise& operator=(const Promise& other) = default;

    Promise& operator=(Promise&& other) FL_NOEXCEPT = default;

    bool valid() const FL_NOEXCEPT {
        return mImpl != nullptr;
    }

    Promise& then(fl::function<void(const T&)> callback) FL_NOEXCEPT {
        if (!valid()) return *this;
 
        mImpl->set_then_callback(fl::move(callback));
        return *this;
    }

    Promise& catch_(fl::function<void(const Error&)> callback) FL_NOEXCEPT {
        if (!valid()) return *this;
 
        mImpl->set_catch_callback(fl::move(callback));
        return *this;
    }

    void update() FL_NOEXCEPT {
        if (!valid()) return;
        mImpl->update();
    }

    bool is_completed() const FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->is_completed();
    }

    bool is_resolved() const FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->is_resolved();
    }

    bool is_rejected() const FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->is_rejected();
    }

    const T& value() const FL_NOEXCEPT {
        if (!valid()) {
            static const T default_value{};
            return default_value;
        }
        return mImpl->value();
    }

    const Error& error() const FL_NOEXCEPT {
        if (!valid()) {
            static const Error default_error;
            return default_error;
        }
        return mImpl->error();
    }

    void clear() FL_NOEXCEPT {
        mImpl.reset();
    }
 
    // ========== PRODUCER INTERFACE (INTERNAL USE) ==========

    bool complete_with_value(const T& value) FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->resolve(value);
    }
 
    bool complete_with_value(T&& value) FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->resolve(fl::move(value));
    }

    bool complete_with_error(const Error& error) FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->reject(error);
    }
 
    bool complete_with_error(const fl::string& error_message) FL_NOEXCEPT {
        if (!valid()) return false;
        return mImpl->reject(Error(error_message));
    }
 
private:
    explicit Promise(fl::shared_ptr<detail::PromiseImpl<T>> impl) FL_NOEXCEPT : mImpl(impl) {}

    fl::shared_ptr<detail::PromiseImpl<T>> mImpl;
};

template<typename T>
Promise<T> make_resolved_promise(T value) FL_NOEXCEPT {
    return Promise<T>::resolve(fl::move(value));
}

template<typename T>
Promise<T> make_rejected_promise(const fl::string& error_message) FL_NOEXCEPT {
    return Promise<T>::reject(Error(error_message));
}

template<typename T>
Promise<T> make_rejected_promise(const char* error_message) FL_NOEXCEPT {
    return Promise<T>::reject(Error(error_message));
}
 
// ============================================================================
// IMPLEMENTATION DETAILS
// ============================================================================
 
namespace detail {

enum class PromiseState_t {
    PENDING,   // Promise is still pending
    RESOLVED,  // Promise completed successfully
    REJECTED   // Promise completed with error
};

template<typename T>
class PromiseImpl {
public:
    PromiseImpl() FL_NOEXCEPT : mState(static_cast<int>(PromiseState_t::PENDING)), mCallbacksProcessed(false) {}

    void set_then_callback(fl::function<void(const T&)> callback) FL_NOEXCEPT {
        mThenCallback = fl::move(callback);
        // If already resolved, process callback immediately
        if (state() == PromiseState_t::RESOLVED && !mCallbacksProcessed) {
            process_callbacks();
        }
    }

    void set_catch_callback(fl::function<void(const Error&)> callback) FL_NOEXCEPT {
        mCatchCallback = fl::move(callback);
        // If already rejected, process callback immediately
        if (state() == PromiseState_t::REJECTED && !mCallbacksProcessed) {
            process_callbacks();
        }
    }

    void update() FL_NOEXCEPT {
        // Process callbacks if we're completed and haven't processed them yet
        if (is_completed() && !mCallbacksProcessed) {
            process_callbacks();
        }
    }

    bool resolve(const T& value) FL_NOEXCEPT {
        if (state() != PromiseState_t::PENDING) return false;
 
        // Write value BEFORE setting state — the atomic store provides
        // a release fence so the reader sees the value after observing
        // the state transition.
        mValue = value;
        set_state(PromiseState_t::RESOLVED);
 
        // Process callback immediately if we have one
        if (mThenCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
 
        return true;
    }
 
    bool resolve(T&& value) FL_NOEXCEPT {
        if (state() != PromiseState_t::PENDING) return false;
 
        mValue = fl::move(value);
        set_state(PromiseState_t::RESOLVED);
 
        if (mThenCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
 
        return true;
    }

    bool reject(const Error& error) FL_NOEXCEPT {
        if (state() != PromiseState_t::PENDING) return false;
 
        mError = error;
        set_state(PromiseState_t::REJECTED);
 
        if (mCatchCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
 
        return true;
    }

    bool is_completed() const FL_NOEXCEPT {
        return state() != PromiseState_t::PENDING;
    }

    bool is_resolved() const FL_NOEXCEPT {
        return state() == PromiseState_t::RESOLVED;
    }

    bool is_rejected() const FL_NOEXCEPT {
        return state() == PromiseState_t::REJECTED;
    }

    const T& value() const FL_NOEXCEPT {
        return mValue;
    }

    const Error& error() const FL_NOEXCEPT {
        return mError;
    }
 
private:
    fl::atomic<int> mState;  // stores PromiseState_t as int (atomics require integer type)
    T mValue;
    Error mError;
 
    fl::function<void(const T&)> mThenCallback;
    fl::function<void(const Error&)> mCatchCallback;
 
    bool mCallbacksProcessed;

    PromiseState_t state() const FL_NOEXCEPT {
        return static_cast<PromiseState_t>(mState.load());
    }

    void set_state(PromiseState_t s) FL_NOEXCEPT {
        mState.store(static_cast<int>(s));
    }

    void process_callbacks() FL_NOEXCEPT {
        if (mCallbacksProcessed) return;
 
        PromiseState_t s = state();
        if (s == PromiseState_t::RESOLVED && mThenCallback) {
            mThenCallback(mValue);
        } else if (s == PromiseState_t::REJECTED && mCatchCallback) {
            mCatchCallback(mError);
        }
 
        mCallbacksProcessed = true;
    }
};
 
} // namespace detail
 
} // namespace task
} // namespace fl