Function SafeCallIntoRAsync

r/src/safe-call-into-r.h:209–248

// `fun`).
template <typename T>
arrow::Future<T> SafeCallIntoRAsync(std::function<arrow::Result<T>(void)> fun,
                                    std::string reason = "unspecified") {
  MainRThread& main_r_thread = MainRThread::GetInstance();
  if (main_r_thread.IsMainThread()) {
    // If we're on the main thread, run the task immediately and let
    // the cpp11::unwind_exception be thrown since it will be caught
    // at the top level.
    return fun();
  } else if (main_r_thread.CanExecuteSafeCallIntoR()) {
    // If we are not on the main thread and have an Executor,
    // use it to run the task on the main R thread. We can't throw
    // a cpp11::unwind_exception here, so we need to propagate it back
    // to RunWithCapturedR through the MainRThread instance.
    return DeferNotOk(main_r_thread.Executor()->Submit([fun,
                                                        reason]() -> arrow::Result<T> {
      // This occurs when some other R code that was previously scheduled to run
      // has errored, in which case we skip execution and let the original
      // error surface.
      if (MainRThread::GetInstance().HasError()) {
        return arrow::Status::Cancelled("Previous R code execution error (", reason, ")");
      }

      try {
        WithoutSignalHandlerContext context;
        return fun();
      } catch (cpp11::unwind_exception& e) {
        // Set the MainRThread error so that subsequent calls to SafeCallIntoR
        // know not to execute R code.
        MainRThread::GetInstance().SetError(arrow::StatusUnwindProtect(e.token, reason));

        // Return an error Status (which is unlikely to surface since RunWithCapturedR
        // will preferentially return the MainRThread error).
        return arrow::Status::Invalid("R code execution error (", reason, ")");
      }
    }));
  } else {
    return arrow::Status::NotImplemented(
        "Call to R (", reason, ") from a non-R thread from an unsupported context");
  }
}

template <typename T>
arrow::Result<T> SafeCallIntoR(std::function<T(void)> fun,