Remove task_future::create(task_state)

This avoids the possibility of creating futures with invalid state (e.g.: with task_state::exception but with an empty exception_ptr)

Author: gilzoide

include/dispatch_queue.hpp

@@ -207,12 +207,12 @@ class dispatch_queue {
 	task<Ret> dispatch_internal(bool run_on_main_loop, F&& f, Args&&... args) {
 		auto work = std::bind(std::move(f), std::forward<Args>(args)...);
 		if (worker_pool) {
-			auto future = detail::task_future<Ret>::create(task_state::pending);
+			auto future = detail::task_future<Ret>::create_pending();
 			worker_pool->enqueue_task({ future->wrap(work) }, run_on_main_loop);
 			return task<Ret>(future);
 		}
 		else if (run_on_main_loop) {
-			auto future = detail::task_future<Ret>::create(task_state::pending);
+			auto future = detail::task_future<Ret>::create_pending();
 			task_queue.push({ future->wrap(work) }, run_on_main_loop);
 			return task<Ret>(future);
 		}

include/promise.hpp

@@ -24,7 +24,7 @@ class promise {
 	}
 
 private:
-	std::shared_ptr<detail::task_future<T>> future = detail::task_future<T>::create();
+	std::shared_ptr<detail::task_future<T>> future = detail::task_future<T>::create_pending();
 };
 
 
@@ -42,7 +42,7 @@ class promise<void> {
 	}
 
 private:
-	std::shared_ptr<detail::task_future<void>> future = detail::task_future<void>::create();
+	std::shared_ptr<detail::task_future<void>> future = detail::task_future<void>::create_pending();
 };
 
 } // end namespace detail

include/task.hpp

@@ -38,7 +38,7 @@ class task {
 	template<typename F>
 	requires (detail::is_instance_of<T, task>::value)
 	auto then(F&& f) const {
-		auto nested_future = detail::task_future<detail::function_result<F, T>>::create();
+		auto nested_future = detail::task_future<detail::function_result<F, T>>::create_pending();
 		task value_this = *this;
 		future->then([=]() {
 			value_this.get().then([=](auto t) {

include/task_future.hpp

@@ -116,22 +116,29 @@ class task_future : public task_future_base, public std::enable_shared_from_this
 		}
 	}
 
-	static std::shared_ptr<task_future> create(task_state state = task_state::pending) {
-		return std::make_shared<task_future>(private_construct{}, state);
+	static std::shared_ptr<task_future> create_pending() {
+		return std::make_shared<task_future>(private_construct{}, task_state::pending);
+	}
+	static std::shared_ptr<task_future> create_ready(T&& value) {
+		return std::make_shared<task_future>(private_construct{}, std::move(value));
+	}
+	static std::shared_ptr<task_future> create_exception(std::exception_ptr exception) {
+		return std::make_shared<task_future>(private_construct{}, exception);
 	}
 	template<typename F>
 	static std::shared_ptr<task_future> create(F&& work) {
 		DISPATCH_QUEUE_TRY {
-			return std::make_shared<task_future>(private_construct{}, std::move(work()));
+			auto value = work();
+			return create_ready(std::move(value));
 		}
 		DISPATCH_QUEUE_CATCH(...) {
-			return std::make_shared<task_future>(private_construct{}, std::current_exception());
+			return create_exception(std::current_exception());
 		}
 	}
 
 	template<typename F>
 	auto then(F&& f) {
-		auto continuation_future = task_future<function_result<F>>::create();
+		auto continuation_future = task_future<function_result<F>>::create_pending();
 		std::unique_lock<std::mutex> lock(mutex);
 		if (state == task_state::pending) {
 			continuations.push_back([=]() {
@@ -206,23 +213,29 @@ class task_future<void> : public task_future_base, public std::enable_shared_fro
 	{
 	}
 
-	static std::shared_ptr<task_future> create(task_state state = task_state::pending) {
-		return std::make_shared<task_future>(private_construct{}, state);
+	static std::shared_ptr<task_future> create_pending() {
+		return std::make_shared<task_future>(private_construct{}, task_state::pending);
+	}
+	static std::shared_ptr<task_future> create_ready() {
+		return std::make_shared<task_future>(private_construct{}, task_state::ready);
+	}
+	static std::shared_ptr<task_future> create_exception(std::exception_ptr exception) {
+		return std::make_shared<task_future>(private_construct{}, exception);
 	}
 	template<typename F>
 	static std::shared_ptr<task_future> create(F&& work) {
 		DISPATCH_QUEUE_TRY {
 			work();
-			return std::make_shared<task_future>(private_construct{}, task_state::ready);
+			return create_ready();
 		}
 		DISPATCH_QUEUE_CATCH(...) {
-			return std::make_shared<task_future>(private_construct{}, std::current_exception());
+			return create_exception(std::current_exception());
 		}
 	}
 
 	template<typename F>
 	auto then(F&& f) {
-		auto continuation_future = task_future<function_result<F>>::create();
+		auto continuation_future = task_future<function_result<F>>::create_pending();
 		std::unique_lock<std::mutex> lock(mutex);
 		if (state == task_state::pending) {
 			continuations.push_back([=]() {