BlackMATov/promise.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/promise.hpp.git synced 2025-12-16 22:19:38 +07:00
Code Issues Packages Projects Releases Wiki Activity

fix except exception safety

Browse Source
This commit is contained in:
Matvey Cherevko
2018-12-14 02:35:46 +07:00
parent ce63cb6204
commit 3bc274228c
2 changed files with 136 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
promise.hpp
View File

@@ -178,16 +178,16 @@ namespace promise_hpp
then([ then([
n = next, n = next,
f = std::forward<ResolveF>(on_resolve) f = std::forward<ResolveF>(on_resolve)
](const T& v) mutable { ](auto&& v) mutable {
auto np = invoke_hpp::invoke( auto np = invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
np.then([n]() mutable { std::move(np).then([n]() mutable {
n.resolve(); n.resolve();
}, [n](std::exception_ptr e) mutable { }).except([n](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
}, [n = next](std::exception_ptr e) mutable { }).except([n = next](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
@@ -205,16 +205,16 @@ namespace promise_hpp
then([ then([
n = next, n = next,
f = std::forward<ResolveF>(on_resolve) f = std::forward<ResolveF>(on_resolve)
](const T& v) mutable { ](auto&& v) mutable {
auto np = invoke_hpp::invoke( auto np = invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
np.then([n](const typename ResolveFR::value_type& nv) mutable { std::move(np).then([n](auto&& nv) mutable {
n.resolve(nv); n.resolve(std::forward<decltype(nv)>(nv));
}, [n](std::exception_ptr e) mutable { }).except([n](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
}, [n = next](std::exception_ptr e) mutable { }).except([n = next](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
@@ -225,10 +225,10 @@ namespace promise_hpp
auto then_all(ResolveF&& on_resolve) { auto then_all(ResolveF&& on_resolve) {
return then([ return then([
f = std::forward<ResolveF>(on_resolve) f = std::forward<ResolveF>(on_resolve)
](const T& v) mutable { ](auto&& v) mutable {
auto r = invoke_hpp::invoke( auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
return make_all_promise(std::move(r)); return make_all_promise(std::move(r));
}); });
} }
@@ -237,10 +237,10 @@ namespace promise_hpp
auto then_any(ResolveF&& on_resolve) { auto then_any(ResolveF&& on_resolve) {
return then([ return then([
f = std::forward<ResolveF>(on_resolve) f = std::forward<ResolveF>(on_resolve)
](const T& v) mutable { ](auto&& v) mutable {
auto r = invoke_hpp::invoke( auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
return make_any_promise(std::move(r)); return make_any_promise(std::move(r));
}); });
} }
@@ -274,14 +274,13 @@ namespace promise_hpp
template < typename RejectF > template < typename RejectF >
promise<T> except(RejectF&& on_reject) { promise<T> except(RejectF&& on_reject) {
return then( return then(
[](const T& value) { return value; }, [](auto&& v) { return std::forward<decltype(v)>(v); },
std::forward<RejectF>(on_reject)); std::forward<RejectF>(on_reject));
} }
template < typename U > template < typename U >
bool resolve(U&& value) { bool resolve(U&& value) {
return state_->resolve( return state_->resolve(std::forward<U>(value));
std::forward<U>(value));
} }
bool reject(std::exception_ptr e) noexcept { bool reject(std::exception_ptr e) noexcept {
@@ -391,10 +390,10 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF > template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<std::is_void<U>::value, void> std::enable_if_t<std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& resolve, RejectF&& reject) { attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
auto reject_h = [ auto reject_h = [
n = next, n = next,
f = std::forward<RejectF>(reject) f = std::forward<RejectF>(on_reject)
](std::exception_ptr e) mutable { ](std::exception_ptr e) mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
@@ -408,18 +407,15 @@ namespace promise_hpp
auto resolve_h = [ auto resolve_h = [
n = next, n = next,
f = std::forward<ResolveF>(resolve), f = std::forward<ResolveF>(on_resolve)
j = reject_h ](auto&& v) mutable {
](const T& v) mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
n.resolve(); n.resolve();
} catch (...) { } catch (...) {
invoke_hpp::invoke( n.reject(std::current_exception());
std::move(j),
std::current_exception());
} }
}; };
@@ -429,10 +425,10 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF > template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<!std::is_void<U>::value, void> std::enable_if_t<!std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& resolve, RejectF&& reject) { attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
auto reject_h = [ auto reject_h = [
n = next, n = next,
f = std::forward<RejectF>(reject) f = std::forward<RejectF>(on_reject)
](std::exception_ptr e) mutable { ](std::exception_ptr e) mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
@@ -446,18 +442,15 @@ namespace promise_hpp
auto resolve_h = [ auto resolve_h = [
n = next, n = next,
f = std::forward<ResolveF>(resolve), f = std::forward<ResolveF>(on_resolve)
j = reject_h ](auto&& v) mutable {
](const T& v) mutable {
try { try {
auto r = invoke_hpp::invoke( auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f), std::forward<decltype(f)>(f),
v); std::forward<decltype(v)>(v));
n.resolve(std::move(r)); n.resolve(std::move(r));
} catch (...) { } catch (...) {
invoke_hpp::invoke( n.reject(std::current_exception());
std::move(j),
std::current_exception());
} }
}; };
@@ -576,12 +569,12 @@ namespace promise_hpp
]() mutable { ]() mutable {
auto np = invoke_hpp::invoke( auto np = invoke_hpp::invoke(
std::forward<decltype(f)>(f)); std::forward<decltype(f)>(f));
np.then([n]() mutable { std::move(np).then([n]() mutable {
n.resolve(); n.resolve();
}, [n](std::exception_ptr e) mutable { }).except([n](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
}, [n = next](std::exception_ptr e) mutable { }).except([n = next](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
@@ -602,12 +595,12 @@ namespace promise_hpp
]() mutable { ]() mutable {
auto np = invoke_hpp::invoke( auto np = invoke_hpp::invoke(
std::forward<decltype(f)>(f)); std::forward<decltype(f)>(f));
np.then([n](const typename ResolveFR::value_type& nv) mutable { std::move(np).then([n](auto&& nv) mutable {
n.resolve(nv); n.resolve(std::forward<decltype(nv)>(nv));
}, [n](std::exception_ptr e) mutable { }).except([n](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
}, [n = next](std::exception_ptr e) mutable { }).except([n = next](std::exception_ptr e) mutable {
n.reject(e); n.reject(e);
}); });
@@ -777,10 +770,10 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF > template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<std::is_void<U>::value, void> std::enable_if_t<std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& resolve, RejectF&& reject) { attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
auto reject_h = [ auto reject_h = [
n = next, n = next,
f = std::forward<RejectF>(reject) f = std::forward<RejectF>(on_reject)
](std::exception_ptr e) mutable { ](std::exception_ptr e) mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
@@ -794,17 +787,14 @@ namespace promise_hpp
auto resolve_h = [ auto resolve_h = [
n = next, n = next,
f = std::forward<ResolveF>(resolve), f = std::forward<ResolveF>(on_resolve)
j = reject_h
]() mutable { ]() mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
std::forward<decltype(f)>(f)); std::forward<decltype(f)>(f));
n.resolve(); n.resolve();
} catch (...) { } catch (...) {
invoke_hpp::invoke( n.reject(std::current_exception());
std::move(j),
std::current_exception());
} }
}; };
@@ -814,10 +804,10 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF > template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<!std::is_void<U>::value, void> std::enable_if_t<!std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& resolve, RejectF&& reject) { attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
auto reject_h = [ auto reject_h = [
n = next, n = next,
f = std::forward<RejectF>(reject) f = std::forward<RejectF>(on_reject)
](std::exception_ptr e) mutable { ](std::exception_ptr e) mutable {
try { try {
invoke_hpp::invoke( invoke_hpp::invoke(
@@ -831,17 +821,14 @@ namespace promise_hpp
auto resolve_h = [ auto resolve_h = [
n = next, n = next,
f = std::forward<ResolveF>(resolve), f = std::forward<ResolveF>(on_resolve)
j = reject_h
]() mutable { ]() mutable {
try { try {
auto r = invoke_hpp::invoke( auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f)); std::forward<decltype(f)>(f));
n.resolve(std::move(r)); n.resolve(std::move(r));
} catch (...) { } catch (...) {
invoke_hpp::invoke( n.reject(std::current_exception());
std::move(j),
std::current_exception());
} }
}; };
@@ -1020,11 +1007,11 @@ namespace promise_hpp
context, context,
resolver, resolver,
result_index result_index
](const child_promise_value_t& v) mutable { ](auto&& v) mutable {
if ( context->apply_result(result_index, v) ) { if ( context->apply_result(result_index, std::forward<decltype(v)>(v)) ) {
resolver(std::move(context->results)); resolver(std::move(context->results));
} }
}, rejector); }).except(rejector);
} }
}); });
} }
@@ -1051,7 +1038,7 @@ namespace promise_hpp
return make_promise<child_promise_value_t>([begin, end](auto&& resolver, auto&& rejector){ return make_promise<child_promise_value_t>([begin, end](auto&& resolver, auto&& rejector){
for ( auto iter = begin; iter != end; ++iter ) { for ( auto iter = begin; iter != end; ++iter ) {
(*iter).then(resolver, rejector); (*iter).then(resolver).except(rejector);
} }
}); });
} }

89
promise_tests.cpp
View File

@@ -404,7 +404,7 @@ TEST_CASE("promise") {
}, [](std::exception_ptr){ }, [](std::exception_ptr){
throw std::logic_error("hello fail2"); throw std::logic_error("hello fail2");
}).except([&call_fail_with_logic_error](std::exception_ptr e){ }).except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail2_exception(e); call_fail_with_logic_error = check_hello_fail_exception(e);
}); });
REQUIRE(not_call_then_on_reject); REQUIRE(not_call_then_on_reject);
REQUIRE(call_fail_with_logic_error); REQUIRE(call_fail_with_logic_error);
@@ -768,6 +768,27 @@ TEST_CASE("promise") {
REQUIRE(not_call_then_on_reject); REQUIRE(not_call_then_on_reject);
REQUIRE(call_fail_with_logic_error); REQUIRE(call_fail_with_logic_error);
} }
{
auto p1 = pr::promise<int>();
auto p2 = pr::promise<int>();
int call_then_count = 0;
int call_except_count = 0;
pr::make_all_promise(std::vector<pr::promise<int>>{p1, p2})
.then([&call_then_count](const std::vector<int>& c){
(void)c;
++call_then_count;
}, [&call_except_count](std::exception_ptr){
++call_except_count;
});
p1.resolve(1);
REQUIRE(call_then_count == 0);
REQUIRE(call_except_count == 0);
p2.reject(std::logic_error("hello fail"));
REQUIRE(call_then_count == 0);
REQUIRE(call_except_count == 1);
}
} }
SECTION("make_any_promise_fail") { SECTION("make_any_promise_fail") {
REQUIRE_THROWS_AS( REQUIRE_THROWS_AS(
@@ -978,3 +999,69 @@ TEST_CASE("get_and_wait") {
} }
} }
} }
TEST_CASE("promise_transformations") {
{
auto p_v = pr::promise<int>()
.then([](int){});
static_assert(
std::is_same<decltype(p_v)::value_type, void>::value,
"unit test fail");
auto p_f = pr::promise<int>()
.then([](int){return 1.f;});
static_assert(
std::is_same<decltype(p_f)::value_type, float>::value,
"unit test fail");
auto p_d = pr::promise<int>()
.then([](int){return 1.f;})
.then([](float){return 1.0;});
static_assert(
std::is_same<decltype(p_d)::value_type, double>::value,
"unit test fail");
}
{
auto p_v = pr::promise<void>()
.then([](){});
static_assert(
std::is_same<decltype(p_v)::value_type, void>::value,
"unit test fail");
auto p_f = pr::promise<void>()
.then([](){return 1.f;});
static_assert(
std::is_same<decltype(p_f)::value_type, float>::value,
"unit test fail");
auto p_d = pr::promise<void>()
.then([](){return 1.f;})
.then([](float){return 1.0;});
static_assert(
std::is_same<decltype(p_d)::value_type, double>::value,
"unit test fail");
}
SECTION("after_except") {
{
auto p_v = pr::promise<int>()
.then([](int)->int{
throw std::logic_error("hello fail");
})
.except([](std::exception_ptr){});
static_assert(
std::is_same<decltype(p_v)::value_type, int>::value,
"unit test fail");
}
{
auto p_v = pr::promise<int>()
.then([](int)->int{
throw std::logic_error("hello fail");
})
.except([](std::exception_ptr){
});
static_assert(
std::is_same<decltype(p_v)::value_type, int>::value,
"unit test fail");
}
}
}