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

Fix a GCC warning:

Browse Source 
```cpp
  ../include/continuable/detail/expected.hpp:344:44: error: declaration of ‘using expected = class cti::detail::util::expected<cti::detail::util::detail::void_guard_tag>’ [-fpermissive]
     using expected = expected<void_guard_tag>;
                                              ^
  ../include/continuable/detail/expected.hpp:171:7: error: changes meaning of ‘expected’ from ‘class cti::detail::util::expected<cti::detail::util::detail::void_guard_tag>’ [-fpermissive]
   class expected
  ```
This commit is contained in:
Denis Blank 2018-01-24 01:29:11 +01:00
parent db8c5b07c9
commit b17d2f9c17
2 changed files with 7 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/continuable/detail/awaiting.hpp
View File

@ -65,7 +65,7 @@ class awaitable {
Continuable continuable_; Continuable continuable_;
/// A cache which is used to pass the result of the continuation /// A cache which is used to pass the result of the continuation
/// to the coroutine. /// to the coroutine.
typename trait_t::expected result_; typename trait_t::expected_type result_;
public: public:
explicit awaitable(Continuable&& continuable) explicit awaitable(Continuable&& continuable)

12
include/continuable/detail/expected.hpp
View File

@ -341,37 +341,37 @@ template <typename T>
struct expected_result_trait; struct expected_result_trait;
template <> template <>
struct expected_result_trait<traits::identity<>> { struct expected_result_trait<traits::identity<>> {
using expected = expected<void_guard_tag>; using expected_type = expected<void_guard_tag>;
static constexpr void_guard_tag wrap() noexcept { static constexpr void_guard_tag wrap() noexcept {
return {}; return {};
} }
static void unwrap(expected&& e) { static void unwrap(expected_type&& e) {
assert(e.is_value()); assert(e.is_value());
(void)e; (void)e;
} }
}; };
template <typename T> template <typename T>
struct expected_result_trait<traits::identity<T>> { struct expected_result_trait<traits::identity<T>> {
using expected = expected<T>; using expected_type = expected<T>;
static auto wrap(T arg) { static auto wrap(T arg) {
return std::move(arg); return std::move(arg);
} }
static auto unwrap(expected&& e) { static auto unwrap(expected_type&& e) {
assert(e.is_value()); assert(e.is_value());
return std::move(e.get_value()); return std::move(e.get_value());
} }
}; };
template <typename First, typename Second, typename... Rest> template <typename First, typename Second, typename... Rest>
struct expected_result_trait<traits::identity<First, Second, Rest...>> { struct expected_result_trait<traits::identity<First, Second, Rest...>> {
using expected = expected<std::tuple<First, Second, Rest...>>; using expected_type = expected<std::tuple<First, Second, Rest...>>;
static auto wrap(First first, Second second, Rest... rest) { static auto wrap(First first, Second second, Rest... rest) {
return std::make_tuple(std::move(first), std::move(second), return std::make_tuple(std::move(first), std::move(second),
std::move(rest)...); std::move(rest)...);
} }
static auto unwrap(expected&& e) { static auto unwrap(expected_type&& e) {
assert(e.is_value()); assert(e.is_value());
return std::move(e.get_value()); return std::move(e.get_value());
} }