Function postToViewerAndWait

src/visualizer/gui/async_task_manager.cpp:200–259

    template <typename F>
    auto postToViewerAndWait(VisualizerImpl* viewer, F&& fn) -> std::invoke_result_t<F> {
        using ResultT = std::invoke_result_t<F>;
        constexpr std::string_view shutdown_error = "Viewer is shutting down";
        constexpr std::string_view task_error = "Viewer work failed";

        if (viewer->isOnViewerThread()) {
            if (!viewer->acceptsPostedWork()) {
                return std::unexpected(std::string(shutdown_error));
            }
            try {
                return std::invoke(std::forward<F>(fn));
            } catch (const std::exception& e) {
                return std::unexpected(std::format("{}: {}", task_error, e.what()));
            } catch (...) {
                return std::unexpected(std::string(task_error));
            }
        }

        auto task = std::make_shared<std::decay_t<F>>(std::forward<F>(fn));
        auto promise = std::make_shared<std::promise<ResultT>>();
        auto completed = std::make_shared<std::atomic_bool>(false);
        auto future = promise->get_future();

        auto finish_with_value = [promise, completed](ResultT value) mutable {
            if (!completed->exchange(true)) {
                promise->set_value(std::move(value));
            }
        };
        auto finish_with_exception = [promise, completed](std::exception_ptr error) {
            if (!completed->exchange(true)) {
                promise->set_exception(std::move(error));
            }
        };

        const bool posted = viewer->postWork(VisualizerImpl::WorkItem{
            .run =
                [task, finish_with_value, finish_with_exception]() mutable {
                    try {
                        finish_with_value(std::invoke(*task));
                    } catch (...) {
                        finish_with_exception(std::current_exception());
                    }
                },
            .cancel =
                [finish_with_value, shutdown_error]() mutable {
                    finish_with_value(std::unexpected(std::string(shutdown_error)));
                }});

        if (!posted) {
            return std::unexpected(std::string(shutdown_error));
        }

        try {
            return future.get();
        } catch (const std::exception& e) {
            return std::unexpected(std::format("{}: {}", task_error, e.what()));
        } catch (...) {
            return std::unexpected(std::string(task_error));