promise_result.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/variant.h"
#include "fl/task/promise.h"  // For Error type
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace task {

template<typename T>
class PromiseResult {
public:
    PromiseResult(const T& value) FL_NO_EXCEPT : mResult(value) {}

    PromiseResult(T&& value) FL_NO_EXCEPT : mResult(fl::move(value)) {}

    PromiseResult(const Error& error) FL_NO_EXCEPT : mResult(error) {}

    PromiseResult(Error&& error) FL_NO_EXCEPT : mResult(fl::move(error)) {}

    bool ok() const FL_NO_EXCEPT {
        return mResult.template is<T>();
    }

    explicit operator bool() const FL_NO_EXCEPT {
        return ok();
    }

    const T& value() const FL_NO_EXCEPT {
        if (!ok()) {
            // Return static empty object instead of crashing
            static const T empty{};
            return empty;
        }
        return mResult.template get<T>();
    }

    T& value() FL_NO_EXCEPT {
        if (!ok()) {
            // Return static empty object instead of crashing
            static T empty{};  // okay static in header
            return empty;
        }
        return mResult.template get<T>();
    }

    const Error& error() const FL_NO_EXCEPT {
        if (ok()) {
            // Return descriptive error for misuse detection
            static const Error empty_error("No error - result contains success value");
            return empty_error;
        }
        return mResult.template get<Error>();
    }

    fl::string error_message() const FL_NO_EXCEPT {
        return ok() ? fl::string() : error().message;
    }

    const fl::variant<T, Error>& variant() const FL_NO_EXCEPT {
        return mResult;
    }
 
private:
    fl::variant<T, Error> mResult;
};

template<typename T>
PromiseResult<T> make_success(const T& value) FL_NO_EXCEPT {
    return PromiseResult<T>(value);
}

template<typename T>
PromiseResult<T> make_success(T&& value) FL_NO_EXCEPT {
    return PromiseResult<T>(fl::move(value));
}

template<typename T>
PromiseResult<T> make_error(const Error& error) FL_NO_EXCEPT {
    return PromiseResult<T>(error);
}

template<typename T>
PromiseResult<T> make_error(Error&& error) FL_NO_EXCEPT {
    return PromiseResult<T>(fl::move(error));
}

template<typename T>
PromiseResult<T> make_error(const fl::string& message) FL_NO_EXCEPT {
    return PromiseResult<T>(Error(message));
}

template<typename T>
PromiseResult<T> make_error(const char* message) FL_NO_EXCEPT {
    return PromiseResult<T>(Error(message));
}
 
} // namespace task
} // namespace fl