2021-11-06 03:18:43 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
|
|
*/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <AK/StringView.h>
|
2021-11-08 02:35:58 +03:00
|
|
|
#include <AK/Try.h>
|
2021-12-15 01:02:23 +03:00
|
|
|
#include <AK/Variant.h>
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2022-10-10 00:23:23 +03:00
|
|
|
#if defined(AK_OS_SERENITY) && defined(KERNEL)
|
2023-01-03 17:30:44 +03:00
|
|
|
# include <errno_codes.h>
|
2021-11-06 03:18:43 +03:00
|
|
|
#else
|
|
|
|
# include <errno.h>
|
2021-12-20 13:55:32 +03:00
|
|
|
# include <string.h>
|
2021-11-06 03:18:43 +03:00
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace AK {
|
|
|
|
|
|
|
|
class Error {
|
|
|
|
public:
|
2023-02-09 21:47:28 +03:00
|
|
|
ALWAYS_INLINE Error(Error&&) = default;
|
|
|
|
ALWAYS_INLINE Error& operator=(Error&&) = default;
|
|
|
|
|
2022-12-26 17:17:22 +03:00
|
|
|
[[nodiscard]] static Error from_errno(int code) { return Error(code); }
|
2023-02-05 13:27:38 +03:00
|
|
|
|
|
|
|
// NOTE: For calling this method from within kernel code, we will simply print
|
|
|
|
// the error message and return the errno code.
|
|
|
|
// For calling this method from userspace programs, we will simply return from
|
|
|
|
// the Error::from_string_view method!
|
|
|
|
[[nodiscard]] static Error from_string_view_or_print_error_and_return_errno(StringView string_literal, int code);
|
2022-12-26 17:17:22 +03:00
|
|
|
[[nodiscard]] static Error from_syscall(StringView syscall_name, int rc) { return Error(syscall_name, rc); }
|
|
|
|
[[nodiscard]] static Error from_string_view(StringView string_literal) { return Error(string_literal); }
|
2022-07-11 20:57:32 +03:00
|
|
|
|
2023-02-09 22:15:58 +03:00
|
|
|
[[nodiscard]] static Error copy(Error const& error)
|
|
|
|
{
|
|
|
|
return Error(error);
|
|
|
|
}
|
|
|
|
|
2022-07-11 20:57:32 +03:00
|
|
|
// NOTE: Prefer `from_string_literal` when directly typing out an error message:
|
|
|
|
//
|
|
|
|
// return Error::from_string_literal("Class: Some failure");
|
|
|
|
//
|
|
|
|
// If you need to return a static string based on a dynamic condition (like
|
|
|
|
// picking an error from an array), then prefer `from_string_view` instead.
|
|
|
|
template<size_t N>
|
2022-12-26 17:17:22 +03:00
|
|
|
[[nodiscard]] ALWAYS_INLINE static Error from_string_literal(char const (&string_literal)[N])
|
2022-07-11 20:57:32 +03:00
|
|
|
{
|
|
|
|
return from_string_view(StringView { string_literal, N - 1 });
|
|
|
|
}
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2022-12-10 18:59:22 +03:00
|
|
|
// Note: Don't call this from C++; it's here for Jakt interop (as the name suggests).
|
|
|
|
template<SameAs<StringView> T>
|
|
|
|
ALWAYS_INLINE static Error __jakt_from_string_literal(T string)
|
|
|
|
{
|
|
|
|
return from_string_view(string);
|
|
|
|
}
|
|
|
|
|
2022-06-08 16:56:21 +03:00
|
|
|
bool operator==(Error const& other) const
|
|
|
|
{
|
|
|
|
return m_code == other.m_code && m_string_literal == other.m_string_literal && m_syscall == other.m_syscall;
|
|
|
|
}
|
|
|
|
|
2021-11-06 03:18:43 +03:00
|
|
|
bool is_errno() const { return m_code != 0; }
|
2021-11-22 18:00:53 +03:00
|
|
|
bool is_syscall() const { return m_syscall; }
|
2021-11-06 03:18:43 +03:00
|
|
|
|
|
|
|
int code() const { return m_code; }
|
|
|
|
StringView string_literal() const { return m_string_literal; }
|
|
|
|
|
2021-11-07 03:30:35 +03:00
|
|
|
protected:
|
2021-11-06 03:18:43 +03:00
|
|
|
Error(int code)
|
|
|
|
: m_code(code)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-11-07 03:30:35 +03:00
|
|
|
private:
|
2021-11-06 03:18:43 +03:00
|
|
|
Error(StringView string_literal)
|
|
|
|
: m_string_literal(string_literal)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-11-22 18:00:53 +03:00
|
|
|
Error(StringView syscall_name, int rc)
|
2022-12-22 16:56:32 +03:00
|
|
|
: m_string_literal(syscall_name)
|
|
|
|
, m_code(-rc)
|
2021-11-22 18:00:53 +03:00
|
|
|
, m_syscall(true)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2023-02-09 21:47:28 +03:00
|
|
|
Error(Error const&) = default;
|
|
|
|
Error& operator=(Error const&) = default;
|
|
|
|
|
2021-11-06 03:18:43 +03:00
|
|
|
StringView m_string_literal;
|
2022-12-22 16:56:32 +03:00
|
|
|
int m_code { 0 };
|
2021-11-22 18:00:53 +03:00
|
|
|
bool m_syscall { false };
|
2021-11-06 03:18:43 +03:00
|
|
|
};
|
|
|
|
|
2022-12-10 14:59:20 +03:00
|
|
|
template<typename T, typename E>
|
2022-10-07 15:52:47 +03:00
|
|
|
class [[nodiscard]] ErrorOr {
|
2022-12-28 23:12:03 +03:00
|
|
|
template<typename U, typename F>
|
|
|
|
friend class ErrorOr;
|
|
|
|
|
2021-11-06 03:18:43 +03:00
|
|
|
public:
|
2022-12-10 14:59:20 +03:00
|
|
|
using ResultType = T;
|
|
|
|
using ErrorType = E;
|
|
|
|
|
2022-10-17 01:06:11 +03:00
|
|
|
ErrorOr()
|
|
|
|
requires(IsSame<T, Empty>)
|
2022-10-07 15:52:47 +03:00
|
|
|
: m_value_or_error(Empty {})
|
|
|
|
{
|
|
|
|
}
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2022-12-09 19:38:09 +03:00
|
|
|
ALWAYS_INLINE ErrorOr(ErrorOr&&) = default;
|
|
|
|
ALWAYS_INLINE ErrorOr& operator=(ErrorOr&&) = default;
|
|
|
|
|
2023-02-09 21:47:28 +03:00
|
|
|
ErrorOr(ErrorOr const&) = delete;
|
|
|
|
ErrorOr& operator=(ErrorOr const&) = delete;
|
2022-12-09 19:38:09 +03:00
|
|
|
|
|
|
|
template<typename U>
|
|
|
|
ALWAYS_INLINE ErrorOr(ErrorOr<U, ErrorType>&& value)
|
2022-12-28 23:12:03 +03:00
|
|
|
requires(IsConvertible<U, T>)
|
|
|
|
: m_value_or_error(value.m_value_or_error.visit([](U& v) { return Variant<T, ErrorType>(move(v)); }, [](ErrorType& error) { return Variant<T, ErrorType>(move(error)); }))
|
2022-12-09 19:38:09 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-11-08 02:36:35 +03:00
|
|
|
template<typename U>
|
2022-10-17 01:06:11 +03:00
|
|
|
ALWAYS_INLINE ErrorOr(U&& value)
|
2022-12-09 19:38:09 +03:00
|
|
|
requires(
|
|
|
|
requires { T(declval<U>()); } || requires { ErrorType(declval<RemoveCVReference<U>>()); })
|
2022-10-07 15:52:47 +03:00
|
|
|
: m_value_or_error(forward<U>(value))
|
2021-11-08 02:36:35 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-10-10 00:23:23 +03:00
|
|
|
#ifdef AK_OS_SERENITY
|
2021-11-07 00:16:50 +03:00
|
|
|
ErrorOr(ErrnoCode code)
|
2022-10-07 15:52:47 +03:00
|
|
|
: m_value_or_error(Error::from_errno(code))
|
2021-11-06 03:18:43 +03:00
|
|
|
{
|
|
|
|
}
|
2021-11-07 00:16:50 +03:00
|
|
|
#endif
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2021-12-15 01:02:23 +03:00
|
|
|
T& value()
|
2021-11-06 03:18:43 +03:00
|
|
|
{
|
2022-10-07 15:52:47 +03:00
|
|
|
return m_value_or_error.template get<T>();
|
2021-11-06 03:18:43 +03:00
|
|
|
}
|
2022-10-07 15:52:47 +03:00
|
|
|
T const& value() const { return m_value_or_error.template get<T>(); }
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2022-10-07 15:52:47 +03:00
|
|
|
ErrorType& error() { return m_value_or_error.template get<ErrorType>(); }
|
|
|
|
ErrorType const& error() const { return m_value_or_error.template get<ErrorType>(); }
|
|
|
|
|
|
|
|
bool is_error() const { return m_value_or_error.template has<ErrorType>(); }
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2021-12-15 01:02:23 +03:00
|
|
|
T release_value() { return move(value()); }
|
|
|
|
ErrorType release_error() { return move(error()); }
|
2021-11-06 03:18:43 +03:00
|
|
|
|
2022-02-06 15:49:51 +03:00
|
|
|
T release_value_but_fixme_should_propagate_errors()
|
|
|
|
{
|
|
|
|
VERIFY(!is_error());
|
|
|
|
return release_value();
|
|
|
|
}
|
2021-11-06 13:29:32 +03:00
|
|
|
|
2021-11-06 03:18:43 +03:00
|
|
|
private:
|
2022-10-07 15:52:47 +03:00
|
|
|
Variant<T, ErrorType> m_value_or_error;
|
2021-11-06 03:18:43 +03:00
|
|
|
};
|
|
|
|
|
2021-11-07 03:30:35 +03:00
|
|
|
template<typename ErrorType>
|
2022-10-07 15:52:47 +03:00
|
|
|
class [[nodiscard]] ErrorOr<void, ErrorType> : public ErrorOr<Empty, ErrorType> {
|
2021-11-06 03:18:43 +03:00
|
|
|
public:
|
2022-12-10 14:59:20 +03:00
|
|
|
using ResultType = void;
|
2022-10-07 15:52:47 +03:00
|
|
|
using ErrorOr<Empty, ErrorType>::ErrorOr;
|
2021-11-06 03:18:43 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2022-11-26 14:18:30 +03:00
|
|
|
#if USING_AK_GLOBALLY
|
2021-11-06 12:34:14 +03:00
|
|
|
using AK::Error;
|
2021-11-06 03:18:43 +03:00
|
|
|
using AK::ErrorOr;
|
2022-11-26 14:18:30 +03:00
|
|
|
#endif
|