Function vec_to_arrow_ChunkedArray

r/src/r_to_arrow.cpp:1299–1342

}

std::shared_ptr<arrow::ChunkedArray> vec_to_arrow_ChunkedArray(
    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_inferred) {
  // short circuit if `x` is already a chunked array
  if (Rf_inherits(x, "ChunkedArray")) {
    return cpp11::as_cpp<std::shared_ptr<arrow::ChunkedArray>>(x);
  }

  // short circuit if `x` is an Array
  if (Rf_inherits(x, "Array")) {
    return std::make_shared<arrow::ChunkedArray>(
        cpp11::as_cpp<std::shared_ptr<arrow::Array>>(x));
  }

  RConversionOptions options;
  options.strict = !type_inferred;
  options.type = type;
  options.size = arrow::r::vec_size(x);

  // If we can handle this in C++ we do so; otherwise we use the
  // AsArrowArrayConverter, which calls as_arrow_array().
  std::unique_ptr<RConverter> converter;
  if (can_convert_native(x) && type->id() != Type::EXTENSION) {
    // short circuit if `x` is an altrep vector that shells a chunked Array
    auto maybe = altrep::vec_to_arrow_altrep_bypass(x);
    if (maybe.get() && maybe->type()->Equals(type)) {
      return maybe;
    }

    // maybe short circuit when zero-copy is possible
    if (can_reuse_memory(x, type)) {
      return std::make_shared<arrow::ChunkedArray>(vec_to_arrow__reuse_memory(x));
    }

    // Otherwise go through the converter API.
    converter = ValueOrStop(MakeConverter<RConverter, RConverterTrait>(
        options.type, options, gc_memory_pool()));
  } else {
    converter = std::unique_ptr<RConverter>(new AsArrowArrayConverter());
    StopIfNotOk(converter->Construct(type, options, gc_memory_pool()));
  }

  StopIfNotOk(converter->Extend(x, options.size));
  return ValueOrStop(converter->ToChunkedArray());
}

std::shared_ptr<arrow::Array> vec_to_arrow_Array(
    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_inferred) {