coffee/continuable
1
0
Fork 0
mirror of https://github.com/Naios/continuable.git synced 2025-12-06 16:56:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Rename cti::expected -> cti::result

Browse Source
This commit is contained in:
Denis Blank 2018-11-25 02:23:08 +01:00
parent 93b1d27b07
commit ffa3b9ee1b
8 changed files with 95 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/continuable/continuable-base.hpp
View File

@ -35,8 +35,8 @@
#include <cstddef>
#include <type_traits>
#include <utility>
#include <continuable/continuable-expected.hpp>
#include <continuable/continuable-primitives.hpp>
#include <continuable/continuable-result.hpp>
#include <continuable/detail/connection/connection-all.hpp>
#include <continuable/detail/connection/connection-any.hpp>
#include <continuable/detail/connection/connection-seq.hpp>
@ -904,11 +904,11 @@ auto recover(Args&&... args) {
inline auto rethrow(exception_t exception) {
// NOLINTNEXTLINE(hicpp-move-const-arg, performance-move-const-arg)
return make_exceptional_expected(std::move(exception));
return make_exceptional_result(std::move(exception));
}
inline auto cancel() {
return make_empty_expected();
return make_empty_result();
}
/// \}
} // namespace cti

83
include/continuable/continuable-expected.hpp → include/continuable/continuable-result.hpp
View File

@ -28,41 +28,41 @@
SOFTWARE.
**/
#ifndef CONTINUABLE_EXPECTED_HPP_INCLUDED
#define CONTINUABLE_EXPECTED_HPP_INCLUDED
#ifndef CONTINUABLE_RESULT_HPP_INCLUDED
#define CONTINUABLE_RESULT_HPP_INCLUDED
#include <type_traits>
#include <utility>
#include <continuable/continuable-primitives.hpp>
#include <continuable/detail/utility/expected-traits.hpp>
#include <continuable/detail/utility/flat-variant.hpp>
#include <continuable/detail/utility/result-trait.hpp>
#include <continuable/detail/utility/traits.hpp>
namespace cti {
/// A class which is convertible to any expected and that definitly holds no
/// value so the real expected gets invalidated when
/// A class which is convertible to any result and that definitly holds no
/// value so the real result gets invalidated when
/// this object is passed to it
struct empty_expected {};
struct empty_result {};
/// A class which is convertible to any expected and that definitly holds
/// an exception which is then passed to the converted expected object.
class exceptional_expected {
/// A class which is convertible to any result and that definitly holds
/// an exception which is then passed to the converted result object.
class exceptional_result {
exception_t exception_;
public:
exceptional_expected() = delete;
exceptional_expected(exceptional_expected const&) = default;
exceptional_expected(exceptional_expected&&) = default;
exceptional_expected& operator=(exceptional_expected const&) = default;
exceptional_expected& operator=(exceptional_expected&&) = default;
~exceptional_expected() = default;
exceptional_result() = delete;
exceptional_result(exceptional_result const&) = default;
exceptional_result(exceptional_result&&) = default;
exceptional_result& operator=(exceptional_result const&) = default;
exceptional_result& operator=(exceptional_result&&) = default;
~exceptional_result() = default;
explicit exceptional_expected(exception_t exception)
explicit exceptional_result(exception_t exception)
// NOLINTNEXTLINE(hicpp-move-const-arg, performance-move-const-arg)
: exception_(std::move(exception)) {
}
exceptional_expected& operator=(exception_t exception) {
exceptional_result& operator=(exception_t exception) {
// NOLINTNEXTLINE(hicpp-move-const-arg, performance-move-const-arg)
exception_ = std::move(exception);
return *this;
@ -84,12 +84,12 @@ public:
}
};
/// A class similar to the one in the expected proposal,
/// A class similar to the one in the result proposal,
/// however it's capable of carrying an exception_t.
// TODO -> async_result
template <typename... T>
class expected {
using trait = detail::expected_trait<T...>;
class result {
using trait = detail::result_trait<T...>;
using value_t = typename trait::value_t;
detail::container::flat_variant<value_t, exception_t> variant_;
@ -102,29 +102,29 @@ public:
std::enable_if_t<((sizeof(A) * 0 + sizeof...(T)) > 0)>* = nullptr,
std::enable_if_t<
std::is_same<A, detail::traits::identity<>>::value>* = nullptr>
explicit expected(A = {}) {
explicit result(A = {}) {
}
explicit expected(expected const&) = default;
explicit expected(expected&&) = default;
expected& operator=(expected const&) = default;
expected& operator=(expected&&) = default;
~expected() = default;
explicit result(result const&) = default;
explicit result(result&&) = default;
result& operator=(result const&) = default;
result& operator=(result&&) = default;
~result() = default;
explicit expected(T... values) : variant_(trait::wrap(std::move(values)...)) {
explicit result(T... values) : variant_(trait::wrap(std::move(values)...)) {
}
explicit expected(exception_t exception) : variant_(std::move(exception)) {
explicit result(exception_t exception) : variant_(std::move(exception)) {
}
explicit expected(empty_expected){};
explicit expected(exceptional_expected exceptional_expected)
: variant_(std::move(exceptional_expected.get_exception())) {
explicit result(empty_result){};
explicit result(exceptional_result exceptional_result)
: variant_(std::move(exceptional_result.get_exception())) {
}
expected& operator=(empty_expected) {
result& operator=(empty_result) {
set_empty();
return *this;
}
expected& operator=(exceptional_expected exceptional_expected) {
set_exception(std::move(exceptional_expected.get_exception()));
result& operator=(exceptional_result exceptional_result) {
set_exception(std::move(exceptional_result.get_exception()));
return *this;
}
@ -183,18 +183,19 @@ public:
};
template <typename... T>
constexpr auto make_expected(T&&... values) {
return expected<detail::traits::unrefcv_t<T>...>(std::forward<T>(values));
constexpr auto make_result(T&&... values) {
return result<detail::traits::unrefcv_t<T>...>(std::forward<T>(values)...);
}
inline auto make_exceptional_expected(exception_t exception) {
// NOLINTNEXTLINE(performance-unnecessary-value-param)
inline auto make_exceptional_result(exception_t exception) {
// NOLINTNEXTLINE(hicpp-move-const-arg, performance-move-const-arg)
return exceptional_expected(std::move(exception));
return exceptional_result(std::move(exception));
}
inline auto make_empty_expected() {
return empty_expected{};
inline auto make_empty_result() {
return empty_result{};
}
} // namespace cti
#endif // CONTINUABLE_EXPECTED_HPP_INCLUDED
#endif // CONTINUABLE_RESULT_HPP_INCLUDED

2
include/continuable/continuable.hpp
View File

@ -48,10 +48,10 @@ namespace cti {}
#include <continuable/continuable-base.hpp>
#include <continuable/continuable-connections.hpp>
#include <continuable/continuable-coroutine.hpp>
#include <continuable/continuable-expected.hpp>
#include <continuable/continuable-primitives.hpp>
#include <continuable/continuable-promise-base.hpp>
#include <continuable/continuable-promisify.hpp>
#include <continuable/continuable-result.hpp>
#include <continuable/continuable-trait.hpp>
#include <continuable/continuable-transforms.hpp>
#include <continuable/continuable-traverse-async.hpp>

2
include/continuable/detail/core/base.hpp
View File

@ -34,8 +34,8 @@
#include <tuple>
#include <type_traits>
#include <utility>
#include <continuable/continuable-expected.hpp>
#include <continuable/continuable-primitives.hpp>
#include <continuable/continuable-result.hpp>
#include <continuable/detail/core/hints.hpp>
#include <continuable/detail/core/types.hpp>
#include <continuable/detail/features.hpp>

12
include/continuable/detail/other/coroutines.hpp
View File

@ -36,8 +36,8 @@
#include <tuple>
#include <type_traits>
#include <experimental/coroutine>
#include <continuable/continuable-expected.hpp>
#include <continuable/continuable-primitives.hpp>
#include <continuable/continuable-result.hpp>
#include <continuable/detail/core/hints.hpp>
#include <continuable/detail/core/types.hpp>
#include <continuable/detail/features.hpp>
@ -55,10 +55,10 @@ namespace awaiting {
using std::experimental::coroutine_handle;
template <typename T>
struct expected_from_identity;
struct result_from_identity;
template <typename... T>
struct expected_from_identity<traits::identity<T...>> {
using expected_t = expected<T...>;
struct result_from_identity<traits::identity<T...>> {
using result_t = result<T...>;
};
/// An object which provides the internal buffer and helper methods
@ -66,13 +66,13 @@ struct expected_from_identity<traits::identity<T...>> {
template <typename Continuable>
class awaitable {
using hint_t = decltype(hints::hint_of(traits::identify<Continuable>{}));
using expected_t = typename expected_from_identity<hint_t>::expected_t;
using result_t = typename result_from_identity<hint_t>::result_t;
/// The continuable which is invoked upon suspension
Continuable continuable_;
/// A cache which is used to pass the result of the continuation
/// to the coroutine.
expected_t result_;
result_t result_;
public:
explicit constexpr awaitable(Continuable&& continuable)

14
include/continuable/detail/utility/expected-traits.hpp → include/continuable/detail/utility/result-trait.hpp
View File

@ -28,8 +28,8 @@
SOFTWARE.
**/
#ifndef CONTINUABLE_DETAIL_EXPECTED_TRAITS_HPP_INCLUDED
#define CONTINUABLE_DETAIL_EXPECTED_TRAITS_HPP_INCLUDED
#ifndef CONTINUABLE_DETAIL_RESULT_TRAIT_HPP_INCLUDED
#define CONTINUABLE_DETAIL_RESULT_TRAIT_HPP_INCLUDED
#include <tuple>
#include <type_traits>
@ -40,9 +40,9 @@
namespace cti {
namespace detail {
template <typename... T>
struct expected_trait;
struct result_trait;
template <>
struct expected_trait<> {
struct result_trait<> {
struct value_t {};
static constexpr value_t wrap() noexcept {
@ -50,7 +50,7 @@ struct expected_trait<> {
}
};
template <typename T>
struct expected_trait<T> {
struct result_trait<T> {
using value_t = T;
static auto wrap(T arg) {
@ -58,7 +58,7 @@ struct expected_trait<T> {
}
};
template <typename First, typename Second, typename... Rest>
struct expected_trait<First, Second, Rest...> {
struct result_trait<First, Second, Rest...> {
using value_t = std::tuple<First, Second, Rest...>;
static auto wrap(First first, Second second, Rest... rest) {
@ -69,4 +69,4 @@ struct expected_trait<First, Second, Rest...> {
} // namespace detail
} // namespace cti
#endif // CONTINUABLE_DETAIL_EXPECTED_TRAITS_HPP_INCLUDED
#endif // CONTINUABLE_DETAIL_RESULT_TRAIT_HPP_INCLUDED

2
test/unit-test/CMakeLists.txt
View File

@ -18,7 +18,7 @@ target_link_libraries(test-continuable-base
add_executable(test-continuable-single
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-connection-noinst
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-flat-variant.cpp
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-expected.cpp
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-result.cpp
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-promisify.cpp
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-traverse.cpp
${CMAKE_CURRENT_LIST_DIR}/single/test-continuable-traverse-async.cpp)

68
test/unit-test/single/test-continuable-expected.cpp → test/unit-test/single/test-continuable-result.cpp
View File

@ -23,17 +23,17 @@
#include <memory>
#include <utility>
#include <continuable/continuable-expected.hpp>
#include <continuable/continuable-result.hpp>
#include <continuable/detail/core/types.hpp>
#include <test-continuable.hpp>
using cti::exception_t;
using cti::expected;
using cti::result;
static int const CANARY = 373671;
template <typename T>
struct expected_all_tests : testing::Test {
struct result_all_tests : testing::Test {
template <typename V>
auto supply(V&& value) const {
return std::forward<V>(value);
@ -44,7 +44,7 @@ struct expected_all_tests : testing::Test {
}
};
template <typename T>
struct expected_all_tests<expected<std::unique_ptr<T>>> : testing::Test {
struct result_all_tests<result<std::unique_ptr<T>>> : testing::Test {
template <typename V>
auto supply(V&& value) const {
return std::make_unique<T>(std::forward<V>(value));
@ -55,21 +55,21 @@ struct expected_all_tests<expected<std::unique_ptr<T>>> : testing::Test {
}
};
using copyable_type = expected<int>;
using unique_type = expected<std::unique_ptr<int>>;
using copyable_type = result<int>;
using unique_type = result<std::unique_ptr<int>>;
using expected_test_types = testing::Types<unique_type, copyable_type>;
using result_test_types = testing::Types<unique_type, copyable_type>;
TYPED_TEST_CASE(expected_all_tests, expected_test_types);
TYPED_TEST_CASE(result_all_tests, result_test_types);
TYPED_TEST(expected_all_tests, is_default_constructible) {
TYPED_TEST(result_all_tests, is_default_constructible) {
TypeParam e;
expected<> e1;
expected<int> e2;
expected<int, int> e3;
result<> e1;
result<int> e2;
result<int, int> e3;
}
TYPED_TEST(expected_all_tests, can_carry_errors) {
TYPED_TEST(result_all_tests, can_carry_errors) {
{
TypeParam e(this->supply(CANARY));
@ -88,12 +88,12 @@ TYPED_TEST(expected_all_tests, can_carry_errors) {
}
}
TYPED_TEST(expected_all_tests, is_empty_constructible) {
TYPED_TEST(result_all_tests, is_empty_constructible) {
TypeParam e;
(void)e;
}
TYPED_TEST(expected_all_tests, is_move_constructible) {
TYPED_TEST(result_all_tests, is_move_constructible) {
{
TypeParam e(TypeParam(this->supply(CANARY)));
@ -111,7 +111,7 @@ TYPED_TEST(expected_all_tests, is_move_constructible) {
}
}
TYPED_TEST(expected_all_tests, is_value_move_assignable) {
TYPED_TEST(result_all_tests, is_value_move_assignable) {
TypeParam old(this->supply(CANARY));
TypeParam e;
e = std::move(old);
@ -122,7 +122,7 @@ TYPED_TEST(expected_all_tests, is_value_move_assignable) {
EXPECT_FALSE(e.is_exception());
}
TYPED_TEST(expected_all_tests, is_error_move_assignable) {
TYPED_TEST(result_all_tests, is_error_move_assignable) {
TypeParam old(exception_t{});
TypeParam e;
e = std::move(old);
@ -132,7 +132,7 @@ TYPED_TEST(expected_all_tests, is_error_move_assignable) {
EXPECT_TRUE(e.is_exception());
}
TEST(expected_copyable_tests, is_copy_constructible) {
TEST(result_copyable_tests, is_copy_constructible) {
{
copyable_type const e_old(CANARY);
copyable_type e(e_old);
@ -153,7 +153,7 @@ TEST(expected_copyable_tests, is_copy_constructible) {
}
}
TEST(expected_copyable_tests, is_copy_assignable) {
TEST(result_copyable_tests, is_copy_assignable) {
{
copyable_type const e_old(CANARY);
copyable_type e;
@ -176,8 +176,8 @@ TEST(expected_copyable_tests, is_copy_assignable) {
}
}
TYPED_TEST(expected_all_tests, is_constructible_from_error_helper) {
cti::exceptional_expected e1(exception_t{});
TYPED_TEST(result_all_tests, is_constructible_from_error_helper) {
cti::exceptional_result e1(exception_t{});
{ auto e2 = e1; }
auto e2 = std::move(e1);
@ -188,8 +188,8 @@ TYPED_TEST(expected_all_tests, is_constructible_from_error_helper) {
EXPECT_TRUE(e.is_exception());
}
TYPED_TEST(expected_all_tests, is_assignable_from_error_helper) {
cti::exceptional_expected e1(exception_t{});
TYPED_TEST(result_all_tests, is_assignable_from_error_helper) {
cti::exceptional_result e1(exception_t{});
{ auto e2 = e1; }
auto e2 = std::move(e1);
@ -201,8 +201,8 @@ TYPED_TEST(expected_all_tests, is_assignable_from_error_helper) {
EXPECT_TRUE(e.is_exception());
}
TYPED_TEST(expected_all_tests, is_constructible_from_empty_helper) {
cti::empty_expected e1;
TYPED_TEST(result_all_tests, is_constructible_from_empty_helper) {
cti::empty_result e1;
{ auto e2 = e1; }
auto e2 = std::move(e1);
@ -213,8 +213,8 @@ TYPED_TEST(expected_all_tests, is_constructible_from_empty_helper) {
EXPECT_TRUE(e.is_empty());
}
TYPED_TEST(expected_all_tests, is_assignable_from_empty_helper) {
cti::empty_expected e1;
TYPED_TEST(result_all_tests, is_assignable_from_empty_helper) {
cti::empty_result e1;
{ auto e2 = e1; }
auto e2 = std::move(e1);
@ -227,16 +227,16 @@ TYPED_TEST(expected_all_tests, is_assignable_from_empty_helper) {
}
// This regression test shows a memory leak which happens when using the
// expected class move constructed from another expected object.
TEST(expected_single_test, test_leak_regression) {
// expected_all_tests<cti::detail::util::expected<std::__1::unique_ptr<int,
// result class move constructed from another result object.
TEST(result_single_test, test_leak_regression) {
// result_all_tests<cti::detail::util::result<std::__1::unique_ptr<int,
// std::__1::default_delete<int> > > >::supply<int const&>(int const&)
// const
// continuable/build/../test/unit-test/test-continuable-expected.cpp:52
// continuable/build/../test/unit-test/test-continuable-result.cpp:52
// 3: #3 0x11cf07a in
// expected_all_tests_is_value_assignable_Test<cti::detail::util::expected<std::__1::unique_ptr<int,
// result_all_tests_is_value_assignable_Test<cti::detail::util::result<std::__1::unique_ptr<int,
// std::__1::default_delete<int> > > >::TestBody()
// continuable/build/../test/unit-test/test-continuable-expected.cpp:133:15
// continuable/build/../test/unit-test/test-continuable-result.cpp:133:15
// 3: #4 0x1339e4e in void
// testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test,
// void>(testing::Test*, void (testing::Test::*)(), char const*)
@ -249,7 +249,7 @@ TEST(expected_single_test, test_leak_regression) {
delete val;
});
auto e(expected<std::shared_ptr<int>>(std::move(ptr)));
auto e(result<std::shared_ptr<int>>(std::move(ptr)));
ASSERT_TRUE(e.is_value());
}