promise.h

Go to the documentation of this file.

#pragma once

 
#include "fl/namespace.h"
#include "fl/function.h"
#include "fl/string.h"
#include "fl/shared_ptr.h"
#include "fl/move.h"
 
namespace fl {

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

template<typename T>
class promise {
public:
    static promise<T> create() {
        auto impl = fl::make_shared<detail::PromiseImpl<T>>();
        return promise<T>(impl);
    }
    
    static promise<T> resolve(const T& value) {
        auto p = create();
        p.complete_with_value(value);
        return p;
    }
    
    static promise<T> resolve(T&& value) {
        auto p = create();
        p.complete_with_value(fl::move(value));
        return p;
    }
    
    static promise<T> reject(const Error& error) {
        auto p = create();
        p.complete_with_error(error);
        return p;
    }
    
    static promise<T> reject(const fl::string& error_message) {
        return reject(Error(error_message));
    }
    
    promise() : mImpl(nullptr) {}
    
    promise(const promise& other) = default;
    
    promise(promise&& other) noexcept = default;
    
    promise& operator=(const promise& other) = default;
    
    promise& operator=(promise&& other) noexcept = default;
    
    bool valid() const {
        return mImpl != nullptr;
    }
    
    promise& then(fl::function<void(const T&)> callback) {
        if (!valid()) return *this;
        
        mImpl->set_then_callback(fl::move(callback));
        return *this;
    }
    
    promise& catch_(fl::function<void(const Error&)> callback) {
        if (!valid()) return *this;
        
        mImpl->set_catch_callback(fl::move(callback));
        return *this;
    }
    
    void update() {
        if (!valid()) return;
        mImpl->update();
    }
    
    bool is_completed() const {
        if (!valid()) return false;
        return mImpl->is_completed();
    }
    
    bool is_resolved() const {
        if (!valid()) return false;
        return mImpl->is_resolved();
    }
    
    bool is_rejected() const {
        if (!valid()) return false;
        return mImpl->is_rejected();
    }
    
    const T& value() const {
        if (!valid()) {
            static const T default_value{};
            return default_value;
        }
        return mImpl->value();
    }
    
    const Error& error() const {
        if (!valid()) {
            static const Error default_error;
            return default_error;
        }
        return mImpl->error();
    }
    
    void clear() {
        mImpl.reset();
    }
    
    // ========== PRODUCER INTERFACE (INTERNAL USE) ==========
    
    bool complete_with_value(const T& value) {
        if (!valid()) return false;
        return mImpl->resolve(value);
    }
    
    bool complete_with_value(T&& value) {
        if (!valid()) return false;
        return mImpl->resolve(fl::move(value));
    }
    
    bool complete_with_error(const Error& error) {
        if (!valid()) return false;
        return mImpl->reject(error);
    }
    
    bool complete_with_error(const fl::string& error_message) {
        if (!valid()) return false;
        return mImpl->reject(Error(error_message));
    }
 
private:
    explicit promise(fl::shared_ptr<detail::PromiseImpl<T>> impl) : mImpl(impl) {}
    
    fl::shared_ptr<detail::PromiseImpl<T>> mImpl;
};

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

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

template<typename T>
promise<T> make_rejected_promise(const char* error_message) {
    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() : mState(PromiseState_t::PENDING), mCallbacksProcessed(false) {}
    
    void set_then_callback(fl::function<void(const T&)> callback) {
        mThenCallback = fl::move(callback);
        // If already resolved, process callback immediately
        if (mState == PromiseState_t::RESOLVED && !mCallbacksProcessed) {
            process_callbacks();
        }
    }
    
    void set_catch_callback(fl::function<void(const Error&)> callback) {
        mCatchCallback = fl::move(callback);
        // If already rejected, process callback immediately
        if (mState == PromiseState_t::REJECTED && !mCallbacksProcessed) {
            process_callbacks();
        }
    }
    
    void update() {
        // Process callbacks if we're completed and haven't processed them yet
        if (is_completed() && !mCallbacksProcessed) {
            process_callbacks();
        }
    }
    
    bool resolve(const T& value) {
        if (mState != PromiseState_t::PENDING) return false;
        
        mValue = value;
        mState = PromiseState_t::RESOLVED;
        
        // Process callback immediately if we have one
        if (mThenCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
        
        return true;
    }
    
    bool resolve(T&& value) {
        if (mState != PromiseState_t::PENDING) return false;
        
        mValue = fl::move(value);
        mState = PromiseState_t::RESOLVED;
        
        // Process callback immediately if we have one
        if (mThenCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
        
        return true;
    }
    
    bool reject(const Error& error) {
        if (mState != PromiseState_t::PENDING) return false;
        
        mError = error;
        mState = PromiseState_t::REJECTED;
        
        // Process callback immediately if we have one
        if (mCatchCallback && !mCallbacksProcessed) {
            process_callbacks();
        }
        
        return true;
    }
    
    bool is_completed() const {
        return mState != PromiseState_t::PENDING;
    }
    
    bool is_resolved() const {
        return mState == PromiseState_t::RESOLVED;
    }
    
    bool is_rejected() const {
        return mState == PromiseState_t::REJECTED;
    }
    
    const T& value() const {
        return mValue;
    }
    
    const Error& error() const {
        return mError;
    }
 
private:
    PromiseState_t mState;
    T mValue;
    Error mError;
    
    fl::function<void(const T&)> mThenCallback;
    fl::function<void(const Error&)> mCatchCallback;
    
    bool mCallbacksProcessed;
    
    void process_callbacks() {
        if (mCallbacksProcessed) return;
        
        if (mState == PromiseState_t::RESOLVED && mThenCallback) {
            mThenCallback(mValue);
        } else if (mState == PromiseState_t::REJECTED && mCatchCallback) {
            mCatchCallback(mError);
        }
        
        mCallbacksProcessed = true;
    }
};
 
} // namespace detail
 
} // namespace fl