// Copyright (C) 2018 The Android Open Source Project
|
//
|
// 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
|
//
|
// http://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.
|
|
#ifndef IORAP_SRC_COMMON_EXPECTED_H_
|
#define IORAP_SRC_COMMON_EXPECTED_H_
|
|
#include <type_traits>
|
#include <utility>
|
|
#include <android-base/logging.h> // CHECK/DCHECK.
|
|
// Ignore the tautological-undefined-compare warning.
|
// We obviously want to do this to protect against undefined behavior
|
// that sets a reference to a null value.
|
#define DCHECK_UB_NOT_NULL(x) \
|
DCHECK(reinterpret_cast<volatile decltype(x)>(x) != nullptr)
|
|
/**
|
* Result<Value, Error>-like interface.
|
*
|
* Subset of the experimental standard C++ proposal (p0323r3)
|
*
|
* Example:
|
*
|
* expected<std::string, status_t> x = function_which_might_fail();
|
* if (x) {
|
* std::string str = x.value();
|
* } else {
|
* status_t err = x.error();
|
* }
|
*/
|
|
namespace iorap {
|
namespace detail {
|
// Use perfect forwarding for expected_data constructors with overloading.
|
struct expected_tag{};
|
struct expected_tag_right : public expected_tag {
|
static constexpr bool is_right_v = true;
|
};
|
struct expected_tag_error : public expected_tag {
|
static constexpr bool is_right_v = false;
|
};
|
|
template <typename T, typename E, bool DefineDestructor>
|
struct expected_data;
|
|
// This doesn't always work because this code could be instantiated with a non-trivial T/E,
|
// and then the union becomes invalid.
|
template <typename T, typename E>
|
struct expected_data<T, E, /*DefineDestructor*/true> {
|
// Mark everything 'constexpr' to keep the code the same as the other partial specialization.
|
|
template <typename U>
|
constexpr expected_data(U&& either, expected_tag_right)
|
: right_{std::forward<U>(either)}, is_right_{true} {}
|
|
template <typename U>
|
constexpr expected_data(U&& either, expected_tag_error)
|
: error_{std::forward<U>(either)}, is_right_{false} {}
|
|
constexpr bool has_value() const {
|
return is_right_;
|
}
|
|
constexpr const T& value() const {
|
return right_;
|
}
|
|
constexpr T& value() {
|
return right_;
|
}
|
|
constexpr const E& error() const {
|
return error_;
|
}
|
|
constexpr E& error() {
|
return error_;
|
}
|
|
// Using an "anonymous union" here allows non-trivial types to be stored.
|
union {
|
T right_;
|
E error_;
|
};
|
|
bool is_right_;
|
|
// Below code differs slightly by handling non-trivial constructors/destructors.
|
bool moved_from_{false};
|
|
// Note: Destructors cannot be templated, so it is illegal to use SFINAE to try to
|
// conditionalize this destructor somehow.
|
~expected_data() {
|
if (moved_from_) { return; }
|
if (is_right_) {
|
right_.~T();
|
} else {
|
error_.~E();
|
}
|
}
|
|
expected_data(expected_data&& other)
|
noexcept(
|
noexcept(T(std::move(other.right_))) &&
|
noexcept(E(std::move(other.error_)))
|
) {
|
DCHECK_UB_NOT_NULL(&other) << __PRETTY_FUNCTION__;
|
DCHECK_EQ(other.moved_from_, false) << __PRETTY_FUNCTION__;
|
if (other.is_right_) {
|
new (&right_) T(std::move(other.right_));
|
} else {
|
new (&error_) E(std::move(other.error_));
|
}
|
other.moved_from_ = true;
|
is_right_ = other.is_right_;
|
}
|
|
expected_data(const expected_data& other) {
|
DCHECK_UB_NOT_NULL(&other) << __PRETTY_FUNCTION__;
|
DCHECK_EQ(other.moved_from_, false) << __PRETTY_FUNCTION__;
|
if (other.is_right_) {
|
new (&right_) T(other.right_);
|
} else {
|
new (&error_) E(other.error_);
|
}
|
is_right_ = other.is_right_;
|
}
|
|
expected_data& operator=(const expected_data& other) {
|
DCHECK_UB_NOT_NULL(&other) << __PRETTY_FUNCTION__;
|
DCHECK_EQ(other.moved_from_, false) << __PRETTY_FUNCTION__;
|
|
if (this == &other) {
|
return *this;
|
}
|
|
if (other.is_right_) {
|
if (!is_right_) {
|
error_.~E();
|
new (&right_) T(other.right_);
|
} else {
|
right_ = other.right_;
|
}
|
} else {
|
if (is_right_) {
|
right_.~T();
|
new (&error_) E(other.error_);
|
} else {
|
error_ = other.error_;
|
}
|
}
|
is_right_ = other.is_right_;
|
|
return *this;
|
}
|
|
expected_data& operator=(expected_data&& other) {
|
DCHECK_UB_NOT_NULL(&other) << __PRETTY_FUNCTION__;
|
DCHECK_EQ(other.moved_from_, false) << __PRETTY_FUNCTION__;
|
|
if (this == &other) {
|
return *this;
|
}
|
|
if (other.is_right_) {
|
if (!is_right_) {
|
error_.~E();
|
new (&right_) T(std::move(other.right_));
|
} else {
|
right_ = std::move(other.right_);
|
}
|
} else {
|
if (is_right_) {
|
right_.~T();
|
new (&error_) E(std::move(other.error_));
|
} else {
|
error_ = std::move(other.error_);
|
}
|
}
|
|
other.moved_from_ = true;
|
is_right_ = other.is_right_;
|
|
return *this;
|
}
|
};
|
|
// Trivial-destructor copy of the above struct.
|
//
|
// A separate copy is required because otherwise compilation fails with an error about
|
// the union having an implicitly deleted constructor.
|
//
|
// Having this implementation gives us the property that
|
//
|
// (is_trivially_destructible<T> && is_trivially_destructible<E>
|
// ==> is_trivially_destructible<expected<T, E>>)
|
template <typename T, typename E>
|
struct expected_data<T, E, /*DefineDestructor*/false> {
|
template <typename U>
|
constexpr expected_data(U&& either, expected_tag_right)
|
: right_{std::forward<U>(either)}, is_right_{true} {}
|
|
template <typename U>
|
constexpr expected_data(U&& either, expected_tag_error)
|
: error_{std::forward<U>(either)}, is_right_{false} {}
|
|
constexpr bool has_value() const {
|
return is_right_;
|
}
|
|
constexpr const T& value() const {
|
return right_;
|
}
|
|
constexpr T& value() {
|
return right_;
|
}
|
|
constexpr const E& error() const {
|
return error_;
|
}
|
|
constexpr E& error() {
|
return error_;
|
}
|
|
// Using an "anonymous union" here allows non-trivial types to be stored.
|
union {
|
T right_;
|
E error_;
|
};
|
|
bool is_right_;
|
|
~expected_data() = default;
|
};
|
|
// Select between trivial and non-trivial implementations. Trivial implementations
|
// are more optimized and constexpr-compatible.
|
template <typename T, typename E>
|
using expected_pick_data_t =
|
expected_data<T, E,
|
!(std::is_trivially_destructible_v<T> && std::is_trivially_destructible_v<E>) >;
|
} // namespace detail
|
|
template <typename E>
|
struct unexpected;
|
|
// Subset of std::experimental::expected proposal (p0323r3).
|
template <typename T, typename E>
|
struct expected {
|
// Never-empty: expected<T,E> values have either 'T' or 'E' in them.
|
template <typename U = T, typename _ = std::enable_if_t<std::is_default_constructible_v<U>>>
|
constexpr expected() noexcept(noexcept(T{})) : expected(T{}) {}
|
|
constexpr expected(const T& value) : data_{value, detail::expected_tag_right{}} {}
|
constexpr expected(T&& value) : data_{std::move(value), detail::expected_tag_right{}} {}
|
constexpr expected(const E& error) : data_{error, detail::expected_tag_error{}} {}
|
constexpr expected(E&& error) : data_{std::move(error), detail::expected_tag_error{}} {}
|
|
template <typename G = E>
|
constexpr expected(unexpected<G> const& u) : expected{u.value()} {}
|
|
template <typename G = E>
|
constexpr expected(unexpected<G>&& u) : expected{std::move(u.value())} {}
|
|
explicit constexpr operator bool() const {
|
return has_value();
|
}
|
|
constexpr bool has_value() const {
|
return data_.has_value();
|
}
|
|
constexpr const T& operator*() const {
|
return data_.value();
|
}
|
|
constexpr T& operator*() {
|
return data_.value();
|
}
|
|
// TODO: arrow operator?
|
|
constexpr T& value() & {
|
CHECK(has_value());
|
return data_.value();
|
}
|
|
constexpr const T& value() const & {
|
CHECK(has_value());
|
return data_.value();
|
}
|
|
constexpr T&& value() && {
|
CHECK(has_value());
|
return std::move(data_.value());
|
}
|
|
constexpr const T& value() const && {
|
CHECK(has_value());
|
return std::move(data_.value());
|
}
|
|
constexpr E& error() {
|
DCHECK(!has_value());
|
return data_.error();
|
}
|
|
constexpr const E& error() const {
|
DCHECK(!has_value());
|
return data_.error();
|
}
|
|
// TODO: other functions such as operator=, unexpected, etc.
|
private:
|
detail::expected_pick_data_t<T, E> data_;
|
};
|
|
// TODO: move to tests file
|
namespace {
|
struct TestType {
|
TestType() {}
|
~TestType() {}
|
};
|
struct TestType2 : TestType {};
|
|
static_assert(std::is_trivially_destructible_v<expected<int, /*error*/double> >);
|
static_assert(!std::is_trivially_destructible_v<expected<TestType, /*error*/double> >);
|
static_assert(!std::is_trivially_destructible_v<expected<int, /*error*/TestType> >);
|
static_assert(!std::is_trivially_destructible_v<expected<TestType, /*error*/TestType2> >);
|
|
// Ensure expected is constexpr-compatible.
|
struct TestCase {
|
static constexpr auto t1 = expected<int, double>{};
|
};
|
} // namespace <anonymous>
|
|
template <typename E>
|
struct unexpected {
|
unexpected() = delete;
|
constexpr explicit unexpected(const E& error) : error_{error} {}
|
constexpr explicit unexpected(E&& error) : error_{std::move(error)} {}
|
constexpr const E& value() const& { return error_; }
|
constexpr E& value() & { return error_; }
|
constexpr E&& value() && { return std::move(error_); }
|
constexpr E const&& value() const&& { return std::move(error_); }
|
private:
|
E error_;
|
};
|
|
template <class E>
|
constexpr bool operator==(const unexpected<E>& x, const unexpected<E>& y) {
|
return x.value() == y.value();
|
}
|
|
template <class E>
|
constexpr bool operator!=(const unexpected<E>& x, const unexpected<E>& y) {
|
return !(x == y);
|
}
|
|
// TODO: move below codes to separate utils file
|
//
|
// future C++20 implementation of std::identity
|
struct identity {
|
template <typename U>
|
constexpr auto operator()(U&& v) const noexcept {
|
return std::forward<U>(v);
|
}
|
};
|
|
// Given a lambda [...](auto&& var) {...}
|
// apply std::forward to 'var' to achieve perfect forwarding.
|
//
|
// Note that this doesn't work when var is a template type, i.e.
|
// template <typename T>
|
// void func(T&& tvar) {...}
|
//
|
// It would be invalid to use this macro with 'tvar' in that context.
|
#define IORAP_FORWARD_LAMBDA(var) std::forward<decltype(var)>(var)
|
|
// Borrowed non-null pointer, i.e. we do not own the lifetime.
|
//
|
// Function calls: This pointer is not used past the call.
|
// Struct fields: This pointer is not used past the lifetime of the struct.
|
template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
|
using borrowed = T _Nonnull;
|
// TODO: need a DCHECK or high warning levels, since null is technically well-defined.
|
|
} // namespace iorap
|
|
#endif // IORAP_SRC_COMMON_EXPECTED_H_
|
