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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// Copyright 2017 Elias Kosunen
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// This file is a part of scnlib:
// https://github.com/eliaskosunen/scnlib
#ifndef SCN_UTIL_EXPECTED_H
#define SCN_UTIL_EXPECTED_H
#include "memory.h"
namespace scn {
SCN_BEGIN_NAMESPACE
/**
* expected-like type.
* For situations where there can be a value in case of success or an error
* code.
*/
template <typename T, typename Error, typename Enable>
class expected;
/**
* expected-like type for default-constructible success values.
* Not optimized for space-efficiency (both members are stored
* simultaneously).
* `error` is used as the error value and discriminant flag.
*/
template <typename T, typename Error>
class expected<T,
Error,
typename std::enable_if<
std::is_default_constructible<T>::value>::type> {
public:
using success_type = T;
using error_type = Error;
constexpr expected() = default;
constexpr expected(success_type s) : m_s(s) {}
constexpr expected(error_type e) : m_e(e) {}
SCN_NODISCARD constexpr bool has_value() const noexcept
{
return m_e == Error{};
}
constexpr explicit operator bool() const noexcept
{
return has_value();
}
constexpr bool operator!() const noexcept
{
return !operator bool();
}
SCN_CONSTEXPR14 success_type& value() & noexcept
{
return m_s;
}
constexpr success_type value() const& noexcept
{
return m_s;
}
SCN_CONSTEXPR14 success_type value() && noexcept
{
return SCN_MOVE(m_s);
}
SCN_CONSTEXPR14 error_type& error() noexcept
{
return m_e;
}
constexpr error_type error() const noexcept
{
return m_e;
}
private:
success_type m_s{};
error_type m_e{error_type::success_tag()};
};
/**
* expected-like type for non-default-constructible success values.
* Not optimized for space-efficiency.
* `error` is used as the error value and discriminant flag.
*/
template <typename T, typename Error>
class expected<T,
Error,
typename std::enable_if<
!std::is_default_constructible<T>::value>::type> {
public:
using success_type = T;
using success_storage = detail::erased_storage<T>;
using error_type = Error;
expected(success_type s) : m_s(SCN_MOVE(s)) {}
constexpr expected(error_type e) : m_e(e) {}
SCN_NODISCARD constexpr bool has_value() const noexcept
{
return m_e == Error{};
}
constexpr explicit operator bool() const noexcept
{
return has_value();
}
constexpr bool operator!() const noexcept
{
return !operator bool();
}
SCN_CONSTEXPR14 success_type& value() noexcept
{
return *m_s;
}
constexpr const success_type& value() const noexcept
{
return *m_s;
}
SCN_CONSTEXPR14 error_type& error() noexcept
{
return m_e;
}
constexpr error_type error() const noexcept
{
return m_e;
}
private:
success_storage m_s{};
error_type m_e{error_type::success_tag()};
};
template <typename T,
typename U = typename std::remove_cv<
typename std::remove_reference<T>::type>::type>
expected<U> make_expected(T&& val)
{
return expected<U>(std::forward<T>(val));
}
SCN_END_NAMESPACE
} // namespace scn
#endif
|
