1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Optional.h>
#include <AK/StringView.h>
#include <AK/Try.h>
#include <AK/Variant.h>
#if defined(__serenity__) && defined(KERNEL)
# include <LibC/errno_codes.h>
#else
# include <errno.h>
# include <string.h>
#endif
namespace AK {
class Error {
public:
static Error from_errno(int code) { return Error(code); }
static Error from_syscall(StringView syscall_name, int rc) { return Error(syscall_name, rc); }
static Error from_string_literal(StringView string_literal) { return Error(string_literal); }
bool is_errno() const { return m_code != 0; }
bool is_syscall() const { return m_syscall; }
int code() const { return m_code; }
StringView string_literal() const { return m_string_literal; }
protected:
Error(int code)
: m_code(code)
{
}
private:
Error(StringView string_literal)
: m_string_literal(string_literal)
{
}
Error(StringView syscall_name, int rc)
: m_code(-rc)
, m_string_literal(syscall_name)
, m_syscall(true)
{
}
int m_code { 0 };
StringView m_string_literal;
bool m_syscall { false };
};
template<typename T, typename ErrorType>
class [[nodiscard]] ErrorOr final : public Variant<T, ErrorType> {
public:
using Variant<T, ErrorType>::Variant;
template<typename U>
ALWAYS_INLINE ErrorOr(U&& value) requires(!IsSame<RemoveCVReference<U>, ErrorOr<T>>)
: Variant<T, ErrorType>(forward<U>(value))
{
}
#ifdef __serenity__
ErrorOr(ErrnoCode code)
: Variant<T, ErrorType>(Error::from_errno(code))
{
}
#endif
T& value()
{
return this->template get<T>();
}
T const& value() const { return this->template get<T>(); }
ErrorType& error() { return this->template get<ErrorType>(); }
ErrorType const& error() const { return this->template get<ErrorType>(); }
bool is_error() const { return this->template has<ErrorType>(); }
T release_value() { return move(value()); }
ErrorType release_error() { return move(error()); }
T release_value_but_fixme_should_propagate_errors() { return release_value(); }
private:
// 'downcast' is fishy in this context. Let's hide it by making it private.
using Variant<T, ErrorType>::downcast;
};
// Partial specialization for void value type
template<typename ErrorType>
class [[nodiscard]] ErrorOr<void, ErrorType> {
public:
ErrorOr(ErrorType error)
: m_error(move(error))
{
}
#ifdef __serenity__
ErrorOr(ErrnoCode code)
: m_error(Error::from_errno(code))
{
}
#endif
ErrorOr() = default;
ErrorOr(ErrorOr&& other) = default;
ErrorOr(ErrorOr const& other) = default;
~ErrorOr() = default;
ErrorOr& operator=(ErrorOr&& other) = default;
ErrorOr& operator=(ErrorOr const& other) = default;
ErrorType& error() { return m_error.value(); }
bool is_error() const { return m_error.has_value(); }
ErrorType release_error() { return m_error.release_value(); }
void release_value() { }
private:
Optional<ErrorType> m_error;
};
}
using AK::Error;
using AK::ErrorOr;
|
