blob: 2e7295fbac0091a466af6585cbe5f89a56a66cd4 (
plain)
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
|
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Format.h>
#include <AK/Optional.h>
#include <AK/StringView.h>
#include <AK/Try.h>
#if defined(__serenity__) && defined(KERNEL)
# include <LibC/errno_numbers.h>
#else
# include <errno.h>
#endif
namespace AK {
class Error {
public:
static Error from_errno(int code) { return Error(code); }
static Error from_string_literal(StringView string_literal) { return Error(string_literal); }
bool is_errno() const { return m_code != 0; }
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)
{
}
int m_code { 0 };
StringView m_string_literal;
};
template<typename T, typename ErrorType = Error>
class [[nodiscard]] ErrorOr {
public:
ErrorOr(T const& value)
: m_value(value)
{
}
ErrorOr(T&& value)
: m_value(move(value))
{
}
#ifdef __serenity__
ErrorOr(ErrnoCode code)
: m_error(Error::from_errno(code))
{
}
#endif
ErrorOr(ErrorType&& error)
: m_error(move(error))
{
}
ErrorOr(ErrorOr&& other) = default;
ErrorOr(ErrorOr const& other) = default;
~ErrorOr() = default;
T& value() { return m_value.value(); }
Error& error() { return m_error.value(); }
bool is_error() const { return m_error.has_value(); }
T release_value() { return m_value.release_value(); }
ErrorType release_error() { return m_error.release_value(); }
T release_value_but_fixme_should_propagate_errors() { return release_value(); }
private:
Optional<T> m_value;
Optional<ErrorType> m_error;
};
// Partial specialization for void value type
template<typename ErrorType>
class [[nodiscard]] ErrorOr<void, ErrorType> {
public:
ErrorOr(ErrorType error)
: m_error(move(error))
{
}
ErrorOr() = default;
ErrorOr(ErrorOr&& other) = default;
ErrorOr(const ErrorOr& other) = default;
~ErrorOr() = 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;
};
template<>
struct Formatter<Error> : Formatter<FormatString> {
void format(FormatBuilder& builder, Error const& error)
{
if (error.is_errno())
return Formatter<FormatString>::format(builder, "Error(errno={})", error.code());
return Formatter<FormatString>::format(builder, "Error({})", error.string_literal());
}
};
}
using AK::Error;
using AK::ErrorOr;
|
