From ffa3b9ee1b094950215838ab796b05929e3c5c7b Mon Sep 17 00:00:00 2001 From: Denis Blank Date: Sun, 25 Nov 2018 02:23:08 +0100 Subject: [PATCH] Rename cti::expected -> cti::result --- include/continuable/continuable-base.hpp | 6 +- ...le-expected.hpp => continuable-result.hpp} | 83 ++++++++++--------- include/continuable/continuable.hpp | 2 +- include/continuable/detail/core/base.hpp | 2 +- .../continuable/detail/other/coroutines.hpp | 12 +-- .../{expected-traits.hpp => result-trait.hpp} | 14 ++-- test/unit-test/CMakeLists.txt | 2 +- ...pected.cpp => test-continuable-result.cpp} | 68 +++++++-------- 8 files changed, 95 insertions(+), 94 deletions(-) rename include/continuable/{continuable-expected.hpp => continuable-result.hpp} (68%) rename include/continuable/detail/utility/{expected-traits.hpp => result-trait.hpp} (87%) rename test/unit-test/single/{test-continuable-expected.cpp => test-continuable-result.cpp} (75%) diff --git a/include/continuable/continuable-base.hpp b/include/continuable/continuable-base.hpp index 24fdca5..1af4d18 100644 --- a/include/continuable/continuable-base.hpp +++ b/include/continuable/continuable-base.hpp @@ -35,8 +35,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -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 diff --git a/include/continuable/continuable-expected.hpp b/include/continuable/continuable-result.hpp similarity index 68% rename from include/continuable/continuable-expected.hpp rename to include/continuable/continuable-result.hpp index 1c13034..4441a3d 100644 --- a/include/continuable/continuable-expected.hpp +++ b/include/continuable/continuable-result.hpp @@ -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 #include #include -#include #include +#include #include 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 -class expected { - using trait = detail::expected_trait; +class result { + using trait = detail::result_trait; using value_t = typename trait::value_t; detail::container::flat_variant variant_; @@ -102,29 +102,29 @@ public: std::enable_if_t<((sizeof(A) * 0 + sizeof...(T)) > 0)>* = nullptr, std::enable_if_t< std::is_same>::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 -constexpr auto make_expected(T&&... values) { - return expected...>(std::forward(values)); +constexpr auto make_result(T&&... values) { + return result...>(std::forward(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 diff --git a/include/continuable/continuable.hpp b/include/continuable/continuable.hpp index 7370df8..228dc1a 100644 --- a/include/continuable/continuable.hpp +++ b/include/continuable/continuable.hpp @@ -48,10 +48,10 @@ namespace cti {} #include #include #include -#include #include #include #include +#include #include #include #include diff --git a/include/continuable/detail/core/base.hpp b/include/continuable/detail/core/base.hpp index d43c7d7..2f93595 100644 --- a/include/continuable/detail/core/base.hpp +++ b/include/continuable/detail/core/base.hpp @@ -34,8 +34,8 @@ #include #include #include -#include #include +#include #include #include #include diff --git a/include/continuable/detail/other/coroutines.hpp b/include/continuable/detail/other/coroutines.hpp index 78d58ba..2696263 100644 --- a/include/continuable/detail/other/coroutines.hpp +++ b/include/continuable/detail/other/coroutines.hpp @@ -36,8 +36,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -55,10 +55,10 @@ namespace awaiting { using std::experimental::coroutine_handle; template -struct expected_from_identity; +struct result_from_identity; template -struct expected_from_identity> { - using expected_t = expected; +struct result_from_identity> { + using result_t = result; }; /// An object which provides the internal buffer and helper methods @@ -66,13 +66,13 @@ struct expected_from_identity> { template class awaitable { using hint_t = decltype(hints::hint_of(traits::identify{})); - using expected_t = typename expected_from_identity::expected_t; + using result_t = typename result_from_identity::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) diff --git a/include/continuable/detail/utility/expected-traits.hpp b/include/continuable/detail/utility/result-trait.hpp similarity index 87% rename from include/continuable/detail/utility/expected-traits.hpp rename to include/continuable/detail/utility/result-trait.hpp index 1f8a213..f39010d 100644 --- a/include/continuable/detail/utility/expected-traits.hpp +++ b/include/continuable/detail/utility/result-trait.hpp @@ -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 #include @@ -40,9 +40,9 @@ namespace cti { namespace detail { template -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 -struct expected_trait { +struct result_trait { using value_t = T; static auto wrap(T arg) { @@ -58,7 +58,7 @@ struct expected_trait { } }; template -struct expected_trait { +struct result_trait { using value_t = std::tuple; static auto wrap(First first, Second second, Rest... rest) { @@ -69,4 +69,4 @@ struct expected_trait { } // namespace detail } // namespace cti -#endif // CONTINUABLE_DETAIL_EXPECTED_TRAITS_HPP_INCLUDED +#endif // CONTINUABLE_DETAIL_RESULT_TRAIT_HPP_INCLUDED diff --git a/test/unit-test/CMakeLists.txt b/test/unit-test/CMakeLists.txt index 8d357d5..1307fd9 100644 --- a/test/unit-test/CMakeLists.txt +++ b/test/unit-test/CMakeLists.txt @@ -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) diff --git a/test/unit-test/single/test-continuable-expected.cpp b/test/unit-test/single/test-continuable-result.cpp similarity index 75% rename from test/unit-test/single/test-continuable-expected.cpp rename to test/unit-test/single/test-continuable-result.cpp index 10738ef..696c894 100644 --- a/test/unit-test/single/test-continuable-expected.cpp +++ b/test/unit-test/single/test-continuable-result.cpp @@ -23,17 +23,17 @@ #include #include -#include +#include #include #include using cti::exception_t; -using cti::expected; +using cti::result; static int const CANARY = 373671; template -struct expected_all_tests : testing::Test { +struct result_all_tests : testing::Test { template auto supply(V&& value) const { return std::forward(value); @@ -44,7 +44,7 @@ struct expected_all_tests : testing::Test { } }; template -struct expected_all_tests>> : testing::Test { +struct result_all_tests>> : testing::Test { template auto supply(V&& value) const { return std::make_unique(std::forward(value)); @@ -55,21 +55,21 @@ struct expected_all_tests>> : testing::Test { } }; -using copyable_type = expected; -using unique_type = expected>; +using copyable_type = result; +using unique_type = result>; -using expected_test_types = testing::Types; +using result_test_types = testing::Types; -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 e2; - expected e3; + result<> e1; + result e2; + result 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 > > >::supply(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 > > >::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::*)(), char const*) @@ -249,7 +249,7 @@ TEST(expected_single_test, test_leak_regression) { delete val; }); - auto e(expected>(std::move(ptr))); + auto e(result>(std::move(ptr))); ASSERT_TRUE(e.is_value()); }