expected.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/stdint.h"
#include "fl/stl/variant.h"
#include "fl/stl/string.h"
#include "fl/stl/noexcept.h"
 
namespace fl {

enum class ResultError : u8 {
    OK,                     
    UNKNOWN,                
    INVALID_ARGUMENT,       
    OUT_OF_RANGE,           
    NOT_INITIALIZED,        
    ALREADY_INITIALIZED,    
    ALLOCATION_FAILED,      
    TIMEOUT,                
    BUSY,                   
    NOT_SUPPORTED,          
    IO_ERROR                
};
 
// Forward declaration for expected template
template<typename T, typename E = ResultError> class expected;  // IWYU pragma: keep

template<typename E>
struct ErrorInfo {
    E code;
    fl::string message;
 
    ErrorInfo(E err, const char* msg = nullptr) FL_NO_EXCEPT : code(err), message(msg ? msg : "") {}
};

template<typename T, typename E>
class expected {
public:
    bool ok() const FL_NO_EXCEPT { return mData.template is<T>(); }

    bool has_value() const FL_NO_EXCEPT { return ok(); }

    E error() const FL_NO_EXCEPT {
        auto* err = mData.template ptr<ErrorInfo<E>>();
        return err ? err->code : E{};
    }

    const char* message() const FL_NO_EXCEPT {
        auto* err = mData.template ptr<ErrorInfo<E>>();
        return err ? err->message.c_str() : "";
    }

    T& value() FL_NO_EXCEPT { return mData.template get<T>(); }
    const T& value() const FL_NO_EXCEPT { return mData.template get<T>(); }

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

    static expected success(T value) FL_NO_EXCEPT {
        expected r;
        r.mData = fl::move(value);
        return r;
    }

    static expected failure(E err, const char* msg = nullptr) FL_NO_EXCEPT {
        expected r;
        r.mData = ErrorInfo<E>(err, msg);
        return r;
    }

    expected() FL_NO_EXCEPT : mData(ErrorInfo<E>(E{}, nullptr)) {}

    expected(expected&& other) FL_NO_EXCEPT = default;

    expected& operator=(expected&& other) FL_NO_EXCEPT = default;

    ~expected() FL_NO_EXCEPT = default;
 
private:
    fl::variant<T, ErrorInfo<E>> mData;
 
    // Non-copyable
    expected(const expected&) FL_NO_EXCEPT = delete;
    expected& operator=(const expected&) FL_NO_EXCEPT = delete;
};

struct VoidSuccess {};

template<typename E>
class expected<void, E> {
public:
    bool ok() const FL_NO_EXCEPT { return mData.template is<VoidSuccess>(); }
 
    E error() const FL_NO_EXCEPT {
        auto* err = mData.template ptr<ErrorInfo<E>>();
        return err ? err->code : E{};
    }
 
    const char* message() const FL_NO_EXCEPT {
        auto* err = mData.template ptr<ErrorInfo<E>>();
        return err ? err->message.c_str() : "";
    }
 
    explicit operator bool() const FL_NO_EXCEPT { return ok(); }
 
    static expected success() FL_NO_EXCEPT {
        expected r;
        r.mData = VoidSuccess{};
        return r;
    }
 
    static expected failure(E err, const char* msg = nullptr) FL_NO_EXCEPT {
        expected r;
        r.mData = ErrorInfo<E>(err, msg);
        return r;
    }

    expected() FL_NO_EXCEPT : mData(ErrorInfo<E>(E{}, nullptr)) {}

    expected(expected&& other) FL_NO_EXCEPT = default;

    expected& operator=(expected&& other) FL_NO_EXCEPT = default;

    expected(const expected& other) FL_NO_EXCEPT : mData() {
        if (other.ok()) {
            mData = VoidSuccess{};
        } else {
            auto* err = other.mData.template ptr<ErrorInfo<E>>();
            if (err) {
                mData = ErrorInfo<E>(err->code, err->message.c_str());
            }
        }
    }

    expected& operator=(const expected& other) FL_NO_EXCEPT {
        if (this != &other) {
            if (other.ok()) {
                mData = VoidSuccess{};
            } else {
                auto* err = other.mData.template ptr<ErrorInfo<E>>();
                if (err) {
                    mData = ErrorInfo<E>(err->code, err->message.c_str());
                }
            }
        }
        return *this;
    }

    ~expected() FL_NO_EXCEPT = default;
 
private:
    fl::variant<VoidSuccess, ErrorInfo<E>> mData;
};
 
} // namespace fl