beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/AK/Error.h

134 lines
3.3 KiB
C
Raw Normal View History

AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/StringView.h>
AK: Make Error.h pull in Try.h Users of this API will want TRY().
2021-11-07 23:35:58 +00:00
#include <AK/Try.h>
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
#include <AK/Variant.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#if defined(AK_OS_SERENITY) && defined(KERNEL)
Kernel+LibC: Move errno definitions to Kernel/API/POSIX This fixes at least half of our LibC includes in the kernel. The source of truth for errno codes and their description strings now lives in Kernel/API/POSIX/errno.h as an enumeration, which LibC includes.
2021-09-12 11:29:28 +00:00
# include <LibC/errno_codes.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
#else
# include <errno.h>
AK+LibMain: Improve formatter for AK::Error in userspace Print the full associated string metadata by default (if available.)
2021-12-20 10:55:32 +00:00
# include <string.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
#endif
namespace AK {
class Error {
public:
static Error from_errno(int code) { return Error(code); }
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
static Error from_syscall(StringView syscall_name, int rc) { return Error(syscall_name, rc); }
Everywhere: Split Error::from_string_literal and Error::from_string_view Error::from_string_literal now takes direct char const*s, while Error::from_string_view does what Error::from_string_literal used to do: taking StringViews. This change will remove the need to insert `sv` after error strings when returning string literal errors once StringView(char const*) is removed. No functional changes.
2022-07-11 17:57:32 +00:00
static Error from_string_view(StringView string_literal) { return Error(string_literal); }
// 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>
ALWAYS_INLINE static Error from_string_literal(char const (&string_literal)[N])
{
return from_string_view(StringView { string_literal, N - 1 });
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Add Error::operator==(Error const&)
2022-06-08 13:56:21 +00: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;
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
bool is_errno() const { return m_code != 0; }
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
bool is_syscall() const { return m_syscall; }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
int code() const { return m_code; }
StringView string_literal() const { return m_string_literal; }
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
protected:
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Error(int code)
: m_code(code)
{
}
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
private:
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Error(StringView string_literal)
: m_string_literal(string_literal)
{
}
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
Error(StringView syscall_name, int rc)
: m_code(-rc)
, m_string_literal(syscall_name)
, m_syscall(true)
{
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
int m_code { 0 };
StringView m_string_literal;
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
bool m_syscall { false };
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
AK: Forward declare Error and ErrorOr in AK/Forward.h
2021-11-15 23:41:28 +00:00
template<typename T, typename ErrorType>
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
class [[nodiscard]] ErrorOr {
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
public:
Everywhere: Run clang-format
2022-10-16 22:06:11 +00:00
ErrorOr()
requires(IsSame<T, Empty>)
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(Empty {})
{
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Add some more ways to construct Error and ErrorOr<T> This is preparation for using Error in the kernel instead of KResult.
2021-11-07 23:36:35 +00:00
template<typename U>
Everywhere: Run clang-format
2022-10-16 22:06:11 +00:00
ALWAYS_INLINE ErrorOr(U&& value)
requires(!IsSame<RemoveCVReference<U>, ErrorOr<T, ErrorType>>)
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(forward<U>(value))
AK: Add some more ways to construct Error and ErrorOr<T> This is preparation for using Error in the kernel instead of KResult.
2021-11-07 23:36:35 +00:00
{
}
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#ifdef AK_OS_SERENITY
AK: Make Error and ErrorOr<T> work in Lagom as well :^) ErrnoCode is not a thing outside __serenity__, so let's not make assumptions about it existing.
2021-11-06 21:16:50 +00:00
ErrorOr(ErrnoCode code)
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(Error::from_errno(code))
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
{
}
AK: Make Error and ErrorOr<T> work in Lagom as well :^) ErrnoCode is not a thing outside __serenity__, so let's not make assumptions about it existing.
2021-11-06 21:16:50 +00:00
#endif
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
T& value()
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
{
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
return m_value_or_error.template get<T>();
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
}
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
T const& value() const { return m_value_or_error.template get<T>(); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00: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>(); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
T release_value() { return move(value()); }
ErrorType release_error() { return move(error()); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: VERIFY inside release_value_but_fixme_should_propagate_errors() While the code did already VERIFY that the ErrorOr holds a value, this was done by Variant, so the error message was just that `has<T>()` is false. This is less helpful than I would like, especially if backtraces are not working and this is all you have to go on. Adding this extra VERIFY means the assertion message (`!is_error()`) is easier to understand.
2022-02-06 12:49:51 +00:00
T release_value_but_fixme_should_propagate_errors()
{
VERIFY(!is_error());
return release_value();
}
AK: Add ErrorOr<T>::release_value_but_fixme_should_propagate_errors() This is an alternative to ErrorOr<T>::release_value() that can be used when converting code to signal that we're releasing the value without error propagation as a way to move forward now. This makes these cases much easier to find later on, once more paths for error propagation are available.
2021-11-06 10:29:32 +00:00
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
private:
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
Variant<T, ErrorType> m_value_or_error;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
template<typename ErrorType>
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
class [[nodiscard]] ErrorOr<void, ErrorType> : public ErrorOr<Empty, ErrorType> {
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
public:
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
using ErrorOr<Empty, ErrorType>::ErrorOr;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#if USING_AK_GLOBALLY
AK: Bring AK::Error into the global namespace
2021-11-06 09:34:14 +00:00
using AK::Error;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
using AK::ErrorOr;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#endif
Reference in a new issue Copy permalink