BlackMATov/promise.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/promise.hpp.git synced 2025-12-13 03:46:29 +07:00
Code Issues Packages Projects Releases Wiki Activity

life after except

Browse Source
This commit is contained in:
Matvey Cherevko
2018-12-17 12:59:46 +07:00
parent 8f5f7bc7ab
commit 3f7ceec4b7
2 changed files with 197 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
promise.hpp
View File

@@ -280,7 +280,8 @@ namespace promise_hpp
state_->attach(
next,
std::forward<ResolveF>(on_resolve),
std::forward<RejectF>(on_reject));
std::forward<RejectF>(on_reject),
true);
return next;
}
@@ -290,9 +291,15 @@ namespace promise_hpp
!is_promise<ResolveFR>::value,
promise<ResolveFR>>
then(ResolveF&& on_resolve) {
return then(
promise<ResolveFR> next;
state_->attach(
next,
std::forward<ResolveF>(on_resolve),
[](std::exception_ptr){});
[](std::exception_ptr e) -> ResolveFR {
std::rethrow_exception(e);
},
false);
return next;
}
template < typename RejectF >
@@ -422,18 +429,28 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
attach(
promise<U>& next,
ResolveF&& on_resolve,
RejectF&& on_reject,
bool has_reject)
{
auto reject_h = [
n = next,
f = std::forward<RejectF>(on_reject)
f = std::forward<RejectF>(on_reject),
has_reject
](std::exception_ptr e) mutable {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
if ( has_reject ) {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
n.resolve();
} catch (...) {
n.reject(std::current_exception());
}
} else {
n.reject(e);
} catch (...) {
n.reject(std::current_exception());
}
};
@@ -457,18 +474,28 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<!std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
attach(
promise<U>& next,
ResolveF&& on_resolve,
RejectF&& on_reject,
bool has_reject)
{
auto reject_h = [
n = next,
f = std::forward<RejectF>(on_reject)
f = std::forward<RejectF>(on_reject),
has_reject
](std::exception_ptr e) mutable {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
if ( has_reject ) {
try {
auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
n.resolve(std::move(r));
} catch (...) {
n.reject(std::current_exception());
}
} else {
n.reject(e);
} catch (...) {
n.reject(std::current_exception());
}
};
@@ -683,7 +710,8 @@ namespace promise_hpp
state_->attach(
next,
std::forward<ResolveF>(on_resolve),
std::forward<RejectF>(on_reject));
std::forward<RejectF>(on_reject),
true);
return next;
}
@@ -693,9 +721,15 @@ namespace promise_hpp
!is_promise<ResolveFR>::value,
promise<ResolveFR>>
then(ResolveF&& on_resolve) {
return then(
promise<ResolveFR> next;
state_->attach(
next,
std::forward<ResolveF>(on_resolve),
[](std::exception_ptr){});
[](std::exception_ptr e) -> ResolveFR {
std::rethrow_exception(e);
},
false);
return next;
}
template < typename RejectF >
@@ -821,18 +855,28 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
attach(
promise<U>& next,
ResolveF&& on_resolve,
RejectF&& on_reject,
bool has_reject)
{
auto reject_h = [
n = next,
f = std::forward<RejectF>(on_reject)
f = std::forward<RejectF>(on_reject),
has_reject
](std::exception_ptr e) mutable {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
if ( has_reject ) {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
n.resolve();
} catch (...) {
n.reject(std::current_exception());
}
} else {
n.reject(e);
} catch (...) {
n.reject(std::current_exception());
}
};
@@ -855,18 +899,28 @@ namespace promise_hpp
template < typename U, typename ResolveF, typename RejectF >
std::enable_if_t<!std::is_void<U>::value, void>
attach(promise<U>& next, ResolveF&& on_resolve, RejectF&& on_reject) {
attach(
promise<U>& next,
ResolveF&& on_resolve,
RejectF&& on_reject,
bool has_reject)
{
auto reject_h = [
n = next,
f = std::forward<RejectF>(on_reject)
f = std::forward<RejectF>(on_reject),
has_reject
](std::exception_ptr e) mutable {
try {
invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
if ( has_reject ) {
try {
auto r = invoke_hpp::invoke(
std::forward<decltype(f)>(f),
e);
n.resolve(std::move(r));
} catch (...) {
n.reject(std::current_exception());
}
} else {
n.reject(e);
} catch (...) {
n.reject(std::current_exception());
}
};

119
promise_tests.cpp
View File

@@ -179,16 +179,6 @@ TEST_CASE("promise") {
});
REQUIRE(check_42_int == 42);
}
{
int check_42_int = 0;
auto p = pr::promise<int>();
p.resolve(42);
p.except([](std::exception_ptr){
}).then([&check_42_int](int value){
check_42_int = value;
});
REQUIRE(check_42_int == 42);
}
{
int check_84_int = 0;
bool check_void_call = false;
@@ -252,8 +242,9 @@ TEST_CASE("promise") {
int check_multi_fail = 0;
auto p = pr::promise<>();
p.reject(std::logic_error("hello fail"));
p.except([&check_multi_fail](std::exception_ptr){
p.except([&check_multi_fail](std::exception_ptr e){
++check_multi_fail;
std::rethrow_exception(e);
}).except([&check_multi_fail](std::exception_ptr){
++check_multi_fail;
});
@@ -316,6 +307,7 @@ TEST_CASE("promise") {
});
p.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 0;
});
REQUIRE(call_fail_with_logic_error);
}
@@ -328,6 +320,7 @@ TEST_CASE("promise") {
});
p.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 0;
});
REQUIRE(call_fail_with_logic_error);
}
@@ -356,6 +349,7 @@ TEST_CASE("promise") {
pr::make_rejected_promise<int>(std::logic_error("hello fail"))
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 0;
});
REQUIRE(call_fail_with_logic_error);
}
@@ -703,7 +697,7 @@ TEST_CASE("promise") {
class o_t {
public:
o_t() = delete;
o_t(int) {}
o_t(int i) { (void)i; }
};
pr::promise<>()
@@ -759,7 +753,7 @@ TEST_CASE("promise") {
class o_t {
public:
o_t() = delete;
o_t(int) {}
o_t(int i) { (void)i; }
};
pr::promise<>()
@@ -988,6 +982,7 @@ TEST_CASE("promise") {
pr::make_resolved_promise(42)};
}).except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 0;
});
REQUIRE(call_fail_with_logic_error);
}
@@ -1044,6 +1039,7 @@ TEST_CASE("promise") {
pr::make_rejected_promise<float>(std::logic_error("hello fail")));
}).except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 0;
});
REQUIRE(call_fail_with_logic_error);
}
@@ -1077,6 +1073,25 @@ TEST_CASE("get_and_wait") {
}};
REQUIRE_NOTHROW(p.get());
}
{
const auto time_now = [](){
return std::chrono::high_resolution_clock::now();
};
auto p1 = pr::make_resolved_promise();
REQUIRE_NOTHROW(p1.wait());
REQUIRE(p1.wait_for(std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
REQUIRE(p1.wait_for(std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
REQUIRE(p1.wait_until(time_now() + std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
REQUIRE(p1.wait_until(time_now() + std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
auto p2 = pr::make_resolved_promise<int>(5);
REQUIRE_NOTHROW(p2.wait());
REQUIRE(p2.wait_for(std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
REQUIRE(p2.wait_for(std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
REQUIRE(p2.wait_until(time_now() + std::chrono::milliseconds(-1)) == pr::promise_wait_status::no_timeout);
REQUIRE(p2.wait_until(time_now() + std::chrono::milliseconds(0)) == pr::promise_wait_status::no_timeout);
}
{
auto p = pr::promise<void>();
auto_thread t{[p]() mutable {
@@ -1242,7 +1257,9 @@ TEST_CASE("promise_transformations") {
.then([](int)->int{
throw std::logic_error("hello fail");
})
.except([](std::exception_ptr){});
.except([](std::exception_ptr){
return 0;
});
static_assert(
std::is_same<decltype(p_v)::value_type, int>::value,
"unit test fail");
@@ -1253,6 +1270,7 @@ TEST_CASE("promise_transformations") {
throw std::logic_error("hello fail");
})
.except([](std::exception_ptr){
return 0;
});
static_assert(
std::is_same<decltype(p_v)::value_type, int>::value,
@@ -1260,3 +1278,76 @@ TEST_CASE("promise_transformations") {
}
}
}
TEST_CASE("life_after_except") {
{
int check_42_int = 0;
bool call_fail_with_logic_error = false;
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
p.then([](int v){
return v;
})
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
return 42;
})
.then([&check_42_int](int value){
check_42_int = value;
});
REQUIRE(check_42_int == 42);
REQUIRE(call_fail_with_logic_error);
}
{
int check_42_int = 0;
bool call_fail_with_logic_error = false;
auto p = pr::make_rejected_promise<int>(std::logic_error("hello fail"));
p.then([](int v){
return v;
})
.except([&call_fail_with_logic_error](std::exception_ptr e) -> int {
call_fail_with_logic_error = check_hello_fail_exception(e);
std::rethrow_exception(e);
})
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = call_fail_with_logic_error && check_hello_fail_exception(e);
return 42;
})
.then([&check_42_int](int value){
check_42_int = value;
});
REQUIRE(check_42_int == 42);
REQUIRE(call_fail_with_logic_error);
}
{
bool call_then_after_except = false;
bool call_fail_with_logic_error = false;
auto p = pr::make_rejected_promise(std::logic_error("hello fail"));
p.then([](){})
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
})
.then([&call_then_after_except](){
call_then_after_except = true;
});
REQUIRE(call_then_after_except);
REQUIRE(call_fail_with_logic_error);
}
{
bool call_fail_with_logic_error = false;
bool call_then_after_multi_except = false;
auto p = pr::make_rejected_promise(std::logic_error("hello fail"));
p.then([](){})
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = check_hello_fail_exception(e);
std::rethrow_exception(e);
})
.except([&call_fail_with_logic_error](std::exception_ptr e){
call_fail_with_logic_error = call_fail_with_logic_error && check_hello_fail_exception(e);
})
.then([&call_then_after_multi_except](){
call_then_after_multi_except = true;
});
REQUIRE(call_fail_with_logic_error);
REQUIRE(call_then_after_multi_except);
}
}