class PromiseBinder {
public:
explicit PromiseBinder(Promise<T> promise) : promise_(std::move(promise)) {}
- void operator()(Future<T> future)
- {
- simgrid::xbt::setPromise(promise_, future);
- }
+ void operator()(Future<T> future) { simgrid::xbt::set_promise(promise_, future); }
+
private:
Promise<T> promise_;
};
[](Promise<R> promise, std::shared_ptr<FutureState<T>> state, F continuation) {
// ...set the new future value by running the continuation.
Future<T> future(std::move(state));
- simgrid::xbt::fulfillPromise(promise, [&] { return continuation(std::move(future)); });
+ simgrid::xbt::fulfill_promise(promise, [&] { return continuation(std::move(future)); });
},
std::move(promise), state, std::move(continuation)));
return std::move(future);
try {
auto future = code();
future.then_([&result, self](std::shared_ptr<simgrid::kernel::FutureState<T>>&& value) {
- simgrid::xbt::setPromise(result, simgrid::kernel::Future<T>(value));
+ simgrid::xbt::set_promise(result, simgrid::kernel::Future<T>(value));
simgrid::simix::unblock(self);
});
}
// When the kernel future is ready...
this->future_.then_([&result, self](std::shared_ptr<simgrid::kernel::FutureState<T>>&& value) {
// ... wake up the process with the result of the kernel future.
- simgrid::xbt::setPromise(result, simgrid::kernel::Future<T>(value));
+ simgrid::xbt::set_promise(result, simgrid::kernel::Future<T>(value));
simgrid::simix::unblock(self);
});
}
* @param code What we want to do
* @param promise Where to want to store the result
*/
-template<class R, class F>
-auto fulfillPromise(R& promise, F&& code)
--> decltype(promise.set_value(code()))
+template <class R, class F> auto fulfill_promise(R& promise, F&& code) -> decltype(promise.set_value(code()))
+{
+ try {
+ promise.set_value(std::forward<F>(code)());
+ } catch (...) {
+ promise.set_exception(std::current_exception());
+ }
+}
+template <class R, class F>
+XBT_ATTRIB_DEPRECATED_v323("Please use xbt::fulfill_promise()") auto fulfillPromise(R& promise, F&& code)
+ -> decltype(promise.set_value(code()))
{
try {
promise.set_value(std::forward<F>(code)());
}
}
-template<class P, class F>
-auto fulfillPromise(P& promise, F&& code)
--> decltype(promise.set_value())
+template <class P, class F> auto fulfill_promise(P& promise, F&& code) -> decltype(promise.set_value())
+{
+ try {
+ std::forward<F>(code)();
+ promise.set_value();
+ } catch (...) {
+ promise.set_exception(std::current_exception());
+ }
+}
+template <class P, class F>
+XBT_ATTRIB_DEPRECATED_v323("Please use xbt::fulfill_promise()") auto fulfillPromise(P& promise, F&& code)
+ -> decltype(promise.set_value())
{
try {
std::forward<F>(code)();
* @param promise output (a valid future or a result)
* @param future input (a ready/waitable future or a valid result)
*/
-template<class P, class F> inline
-void setPromise(P& promise, F&& future)
+template <class P, class F> inline void set_promise(P& promise, F&& future)
+{
+ fulfill_promise(promise, [&] { return std::forward<F>(future).get(); });
+}
+template <class P, class F>
+inline XBT_ATTRIB_DEPRECATED_v323("Please use xbt::set_promise()") void setPromise(P& promise, F&& future)
{
- fulfillPromise(promise, [&]{ return std::forward<F>(future).get(); });
+ fulfill_promise(promise, [&] { return std::forward<F>(future).get(); });
}
}
/** Module management function: frees all internal data structures */
void sg_platf_exit() {
- simgrid::surf::on_cluster.disconnectSlots();
- simgrid::s4u::on_platform_created.disconnectSlots();
+ simgrid::surf::on_cluster.disconnect_slots();
+ simgrid::s4u::on_platform_created.disconnect_slots();
/* make sure that we will reinit the models while loading the platf once reinited */
surf_parse_models_setup_already_called = 0;