From 78f69af676a137e45e99e478db4d21612488e4cd Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Mon, 3 Jun 2019 11:24:58 +0200 Subject: [PATCH 01/24] move symbols declaration to their own file, might end up be generated automatically later somehow. --- r/src/arrow_types.h | 13 ++----------- r/src/symbols.h | 27 +++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 11 deletions(-) create mode 100644 r/src/symbols.h diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h index f4dad1bf219..9c5cc28a73c 100644 --- a/r/src/arrow_types.h +++ b/r/src/arrow_types.h @@ -22,8 +22,10 @@ #include #include +#include "./symbols.h" #undef Free + #include #include #include @@ -54,17 +56,6 @@ struct NoDelete { inline void operator()(T* ptr) {} }; -namespace arrow { -namespace r { -struct symbols { - static SEXP units; - static SEXP xp; - static SEXP dot_Internal; - static SEXP inspect; -}; -} // namespace r -} // namespace arrow - namespace Rcpp { namespace internal { diff --git a/r/src/symbols.h b/r/src/symbols.h new file mode 100644 index 00000000000..0c1317ad224 --- /dev/null +++ b/r/src/symbols.h @@ -0,0 +1,27 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +namespace arrow { +namespace r { +struct symbols { + static SEXP units; + static SEXP xp; + static SEXP dot_Internal; + static SEXP inspect; +}; +} // namespace r +} // namespace arrow From 1ed559665948e3f7f949000897cdc26f4c570a54 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 4 Jun 2019 15:59:23 +0200 Subject: [PATCH 02/24] Workaround so that the R package still checks without the C++ library. --- dev/release/rat_exclude_files.txt | 4 +- r/DESCRIPTION | 2 +- r/NAMESPACE | 3 +- r/R/Field.R | 7 +- r/R/RcppExports.R | 844 ------- r/R/generated.R | 831 +++++++ r/R/parquet.R | 6 +- r/R/zzz.R | 8 + r/configure | 18 +- r/data-raw/codegen.R | 160 ++ r/man/arrow_available.Rd | 11 + r/man/field.Rd | 5 +- r/man/read_parquet.Rd | 6 +- r/src/RcppExports.cpp | 2530 -------------------- r/src/Rcpp_arrow_definitions.h | 66 + r/src/Rcpp_arrow_forward.h | 98 + r/src/array.cpp | 38 +- r/src/array__to_vector.cpp | 14 +- r/src/array_from_vector.cpp | 9 +- r/src/arraydata.cpp | 14 +- r/src/arrow_types.h | 158 +- r/src/buffer.cpp | 14 +- r/src/chunkedarray.cpp | 20 +- r/src/column.cpp | 12 +- r/src/compression.cpp | 10 +- r/src/compute.cpp | 14 +- r/src/csv.cpp | 14 +- r/src/datatype.cpp | 104 +- r/src/feather.cpp | 34 +- r/src/field.cpp | 16 +- r/src/generated.cpp | 3603 +++++++++++++++++++++++++++++ r/src/io.cpp | 50 +- r/src/memorypool.cpp | 9 +- r/src/message.cpp | 26 +- r/src/parquet.cpp | 7 +- r/src/recordbatch.cpp | 51 +- r/src/recordbatchreader.cpp | 26 +- r/src/recordbatchwriter.cpp | 14 +- r/src/symbols.h | 2 + r/src/table.cpp | 26 +- r/src/threadpool.cpp | 14 +- r/tests/testthat.R | 1 + r/tests/testthat/helper-arrow.R | 7 + r/tests/testthat/test-field.R | 2 + 44 files changed, 5163 insertions(+), 3745 deletions(-) delete mode 100644 r/R/RcppExports.R create mode 100644 r/R/generated.R create mode 100644 r/data-raw/codegen.R create mode 100644 r/man/arrow_available.Rd delete mode 100644 r/src/RcppExports.cpp create mode 100644 r/src/Rcpp_arrow_definitions.h create mode 100644 r/src/Rcpp_arrow_forward.h create mode 100644 r/src/generated.cpp create mode 100644 r/tests/testthat/helper-arrow.R diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt index bd1123dd03f..06a6feb8b8f 100644 --- a/dev/release/rat_exclude_files.txt +++ b/dev/release/rat_exclude_files.txt @@ -192,8 +192,8 @@ csharp/test/Directory.Build.props *.svg *.devhelp2 *.scss -r/R/RcppExports.R -r/src/RcppExports.cpp +r/R/generated.R +r/src/generated.* r/DESCRIPTION r/LICENSE.md r/NAMESPACE diff --git a/r/DESCRIPTION b/r/DESCRIPTION index c82bf91b629..6c25adfa382 100644 --- a/r/DESCRIPTION +++ b/r/DESCRIPTION @@ -52,7 +52,6 @@ Collate: 'Column.R' 'Field.R' 'List.R' - 'RcppExports.R' 'RecordBatch.R' 'RecordBatchReader.R' 'RecordBatchWriter.R' @@ -67,6 +66,7 @@ Collate: 'csv.R' 'dictionary.R' 'feather.R' + 'generated.R' 'memory_pool.R' 'message.R' 'parquet.R' diff --git a/r/NAMESPACE b/r/NAMESPACE index 4b799571966..bc4f677cc00 100644 --- a/r/NAMESPACE +++ b/r/NAMESPACE @@ -96,7 +96,6 @@ export(FeatherTableWriter) export(FileMode) export(FileOutputStream) export(FixedSizeBufferWriter) -export(GetCpuThreadPoolCapacity) export(MessageReader) export(MessageType) export(MockOutputStream) @@ -105,11 +104,11 @@ export(RecordBatchFileReader) export(RecordBatchFileWriter) export(RecordBatchStreamReader) export(RecordBatchStreamWriter) -export(SetCpuThreadPoolCapacity) export(StatusCode) export(TimeUnit) export(Type) export(array) +export(arrow_available) export(as_tibble) export(boolean) export(buffer) diff --git a/r/R/Field.R b/r/R/Field.R index 4f5636fbfff..440df3db948 100644 --- a/r/R/Field.R +++ b/r/R/Field.R @@ -64,14 +64,17 @@ #' @param metadata currently ignored #' #' @examples -#' field("x", int32()) +#' +#' if(arrow_available()){ +#' field("x", int32()) +#' } #' #' @export field <- function(name, type, metadata) { assert_that(inherits(name, "character"), length(name) == 1L) assert_that(inherits(type, "arrow::DataType")) assert_that(missing(metadata), msg = "metadata= is currently ignored") - shared_ptr(`arrow::Field`, Field__initialize(name, type)) + shared_ptr(`arrow::Field`, Field__initialize(name, type, TRUE)) } .fields <- function(.list){ diff --git a/r/R/RcppExports.R b/r/R/RcppExports.R deleted file mode 100644 index 69745f8bc4b..00000000000 --- a/r/R/RcppExports.R +++ /dev/null @@ -1,844 +0,0 @@ -# Generated by using Rcpp::compileAttributes() -> do not edit by hand -# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 - -Array__Slice1 <- function(array, offset) { - .Call(`_arrow_Array__Slice1`, array, offset) -} - -Array__Slice2 <- function(array, offset, length) { - .Call(`_arrow_Array__Slice2`, array, offset, length) -} - -Array__IsNull <- function(x, i) { - .Call(`_arrow_Array__IsNull`, x, i) -} - -Array__IsValid <- function(x, i) { - .Call(`_arrow_Array__IsValid`, x, i) -} - -Array__length <- function(x) { - .Call(`_arrow_Array__length`, x) -} - -Array__offset <- function(x) { - .Call(`_arrow_Array__offset`, x) -} - -Array__null_count <- function(x) { - .Call(`_arrow_Array__null_count`, x) -} - -Array__type <- function(x) { - .Call(`_arrow_Array__type`, x) -} - -Array__ToString <- function(x) { - .Call(`_arrow_Array__ToString`, x) -} - -Array__type_id <- function(x) { - .Call(`_arrow_Array__type_id`, x) -} - -Array__Equals <- function(lhs, rhs) { - .Call(`_arrow_Array__Equals`, lhs, rhs) -} - -Array__ApproxEquals <- function(lhs, rhs) { - .Call(`_arrow_Array__ApproxEquals`, lhs, rhs) -} - -Array__data <- function(array) { - .Call(`_arrow_Array__data`, array) -} - -Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx) { - .Call(`_arrow_Array__RangeEquals`, self, other, start_idx, end_idx, other_start_idx) -} - -Array__Mask <- function(array) { - .Call(`_arrow_Array__Mask`, array) -} - -DictionaryArray__indices <- function(array) { - .Call(`_arrow_DictionaryArray__indices`, array) -} - -DictionaryArray__dictionary <- function(array) { - .Call(`_arrow_DictionaryArray__dictionary`, array) -} - -Array__as_vector <- function(array) { - .Call(`_arrow_Array__as_vector`, array) -} - -ChunkedArray__as_vector <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__as_vector`, chunked_array) -} - -RecordBatch__to_dataframe <- function(batch, use_threads) { - .Call(`_arrow_RecordBatch__to_dataframe`, batch, use_threads) -} - -Table__to_dataframe <- function(table, use_threads) { - .Call(`_arrow_Table__to_dataframe`, table, use_threads) -} - -Array__infer_type <- function(x) { - .Call(`_arrow_Array__infer_type`, x) -} - -Array__from_vector <- function(x, s_type) { - .Call(`_arrow_Array__from_vector`, x, s_type) -} - -ChunkedArray__from_list <- function(chunks, s_type) { - .Call(`_arrow_ChunkedArray__from_list`, chunks, s_type) -} - -ArrayData__get_type <- function(x) { - .Call(`_arrow_ArrayData__get_type`, x) -} - -ArrayData__get_length <- function(x) { - .Call(`_arrow_ArrayData__get_length`, x) -} - -ArrayData__get_null_count <- function(x) { - .Call(`_arrow_ArrayData__get_null_count`, x) -} - -ArrayData__get_offset <- function(x) { - .Call(`_arrow_ArrayData__get_offset`, x) -} - -ArrayData__buffers <- function(x) { - .Call(`_arrow_ArrayData__buffers`, x) -} - -Buffer__is_mutable <- function(buffer) { - .Call(`_arrow_Buffer__is_mutable`, buffer) -} - -Buffer__ZeroPadding <- function(buffer) { - invisible(.Call(`_arrow_Buffer__ZeroPadding`, buffer)) -} - -Buffer__capacity <- function(buffer) { - .Call(`_arrow_Buffer__capacity`, buffer) -} - -Buffer__size <- function(buffer) { - .Call(`_arrow_Buffer__size`, buffer) -} - -r___RBuffer__initialize <- function(x) { - .Call(`_arrow_r___RBuffer__initialize`, x) -} - -ChunkedArray__length <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__length`, chunked_array) -} - -ChunkedArray__null_count <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__null_count`, chunked_array) -} - -ChunkedArray__num_chunks <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__num_chunks`, chunked_array) -} - -ChunkedArray__chunk <- function(chunked_array, i) { - .Call(`_arrow_ChunkedArray__chunk`, chunked_array, i) -} - -ChunkedArray__chunks <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__chunks`, chunked_array) -} - -ChunkedArray__type <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__type`, chunked_array) -} - -ChunkArray__Slice1 <- function(chunked_array, offset) { - .Call(`_arrow_ChunkArray__Slice1`, chunked_array, offset) -} - -ChunkArray__Slice2 <- function(chunked_array, offset, length) { - .Call(`_arrow_ChunkArray__Slice2`, chunked_array, offset, length) -} - -Column__length <- function(column) { - .Call(`_arrow_Column__length`, column) -} - -Column__null_count <- function(column) { - .Call(`_arrow_Column__null_count`, column) -} - -Column__type <- function(column) { - .Call(`_arrow_Column__type`, column) -} - -Column__data <- function(column) { - .Call(`_arrow_Column__data`, column) -} - -util___Codec__Create <- function(codec) { - .Call(`_arrow_util___Codec__Create`, codec) -} - -io___CompressedOutputStream__Make <- function(codec, raw) { - .Call(`_arrow_io___CompressedOutputStream__Make`, codec, raw) -} - -io___CompressedInputStream__Make <- function(codec, raw) { - .Call(`_arrow_io___CompressedInputStream__Make`, codec, raw) -} - -compute___CastOptions__initialize <- function(allow_int_overflow, allow_time_truncate, allow_float_truncate) { - .Call(`_arrow_compute___CastOptions__initialize`, allow_int_overflow, allow_time_truncate, allow_float_truncate) -} - -Array__cast <- function(array, target_type, options) { - .Call(`_arrow_Array__cast`, array, target_type, options) -} - -ChunkedArray__cast <- function(chunked_array, target_type, options) { - .Call(`_arrow_ChunkedArray__cast`, chunked_array, target_type, options) -} - -RecordBatch__cast <- function(batch, schema, options) { - .Call(`_arrow_RecordBatch__cast`, batch, schema, options) -} - -Table__cast <- function(table, schema, options) { - .Call(`_arrow_Table__cast`, table, schema, options) -} - -csv___ReadOptions__initialize <- function(options) { - .Call(`_arrow_csv___ReadOptions__initialize`, options) -} - -csv___ParseOptions__initialize <- function(options) { - .Call(`_arrow_csv___ParseOptions__initialize`, options) -} - -csv___ConvertOptions__initialize <- function(options) { - .Call(`_arrow_csv___ConvertOptions__initialize`, options) -} - -csv___TableReader__Make <- function(input, read_options, parse_options, convert_options) { - .Call(`_arrow_csv___TableReader__Make`, input, read_options, parse_options, convert_options) -} - -csv___TableReader__Read <- function(table_reader) { - .Call(`_arrow_csv___TableReader__Read`, table_reader) -} - -shared_ptr_is_null <- function(xp) { - .Call(`_arrow_shared_ptr_is_null`, xp) -} - -unique_ptr_is_null <- function(xp) { - .Call(`_arrow_unique_ptr_is_null`, xp) -} - -Int8__initialize <- function() { - .Call(`_arrow_Int8__initialize`) -} - -Int16__initialize <- function() { - .Call(`_arrow_Int16__initialize`) -} - -Int32__initialize <- function() { - .Call(`_arrow_Int32__initialize`) -} - -Int64__initialize <- function() { - .Call(`_arrow_Int64__initialize`) -} - -UInt8__initialize <- function() { - .Call(`_arrow_UInt8__initialize`) -} - -UInt16__initialize <- function() { - .Call(`_arrow_UInt16__initialize`) -} - -UInt32__initialize <- function() { - .Call(`_arrow_UInt32__initialize`) -} - -UInt64__initialize <- function() { - .Call(`_arrow_UInt64__initialize`) -} - -Float16__initialize <- function() { - .Call(`_arrow_Float16__initialize`) -} - -Float32__initialize <- function() { - .Call(`_arrow_Float32__initialize`) -} - -Float64__initialize <- function() { - .Call(`_arrow_Float64__initialize`) -} - -Boolean__initialize <- function() { - .Call(`_arrow_Boolean__initialize`) -} - -Utf8__initialize <- function() { - .Call(`_arrow_Utf8__initialize`) -} - -Date32__initialize <- function() { - .Call(`_arrow_Date32__initialize`) -} - -Date64__initialize <- function() { - .Call(`_arrow_Date64__initialize`) -} - -Null__initialize <- function() { - .Call(`_arrow_Null__initialize`) -} - -Decimal128Type__initialize <- function(precision, scale) { - .Call(`_arrow_Decimal128Type__initialize`, precision, scale) -} - -FixedSizeBinary__initialize <- function(byte_width) { - .Call(`_arrow_FixedSizeBinary__initialize`, byte_width) -} - -Timestamp__initialize1 <- function(unit) { - .Call(`_arrow_Timestamp__initialize1`, unit) -} - -Timestamp__initialize2 <- function(unit, timezone) { - .Call(`_arrow_Timestamp__initialize2`, unit, timezone) -} - -Time32__initialize <- function(unit) { - .Call(`_arrow_Time32__initialize`, unit) -} - -Time64__initialize <- function(unit) { - .Call(`_arrow_Time64__initialize`, unit) -} - -list__ <- function(x) { - .Call(`_arrow_list__`, x) -} - -struct_ <- function(fields) { - .Call(`_arrow_struct_`, fields) -} - -DataType__ToString <- function(type) { - .Call(`_arrow_DataType__ToString`, type) -} - -DataType__name <- function(type) { - .Call(`_arrow_DataType__name`, type) -} - -DataType__Equals <- function(lhs, rhs) { - .Call(`_arrow_DataType__Equals`, lhs, rhs) -} - -DataType__num_children <- function(type) { - .Call(`_arrow_DataType__num_children`, type) -} - -DataType__children_pointer <- function(type) { - .Call(`_arrow_DataType__children_pointer`, type) -} - -DataType__id <- function(type) { - .Call(`_arrow_DataType__id`, type) -} - -schema_ <- function(fields) { - .Call(`_arrow_schema_`, fields) -} - -Schema__ToString <- function(s) { - .Call(`_arrow_Schema__ToString`, s) -} - -Schema__num_fields <- function(s) { - .Call(`_arrow_Schema__num_fields`, s) -} - -Schema__field <- function(s, i) { - .Call(`_arrow_Schema__field`, s, i) -} - -Schema__names <- function(schema) { - .Call(`_arrow_Schema__names`, schema) -} - -ListType__ToString <- function(type) { - .Call(`_arrow_ListType__ToString`, type) -} - -FixedWidthType__bit_width <- function(type) { - .Call(`_arrow_FixedWidthType__bit_width`, type) -} - -DateType__unit <- function(type) { - .Call(`_arrow_DateType__unit`, type) -} - -TimeType__unit <- function(type) { - .Call(`_arrow_TimeType__unit`, type) -} - -DecimalType__precision <- function(type) { - .Call(`_arrow_DecimalType__precision`, type) -} - -DecimalType__scale <- function(type) { - .Call(`_arrow_DecimalType__scale`, type) -} - -TimestampType__timezone <- function(type) { - .Call(`_arrow_TimestampType__timezone`, type) -} - -TimestampType__unit <- function(type) { - .Call(`_arrow_TimestampType__unit`, type) -} - -DictionaryType__initialize <- function(index_type, value_type, ordered) { - .Call(`_arrow_DictionaryType__initialize`, index_type, value_type, ordered) -} - -DictionaryType__index_type <- function(type) { - .Call(`_arrow_DictionaryType__index_type`, type) -} - -DictionaryType__value_type <- function(type) { - .Call(`_arrow_DictionaryType__value_type`, type) -} - -DictionaryType__name <- function(type) { - .Call(`_arrow_DictionaryType__name`, type) -} - -DictionaryType__ordered <- function(type) { - .Call(`_arrow_DictionaryType__ordered`, type) -} - -ipc___feather___TableWriter__SetDescription <- function(writer, description) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__SetDescription`, writer, description)) -} - -ipc___feather___TableWriter__SetNumRows <- function(writer, num_rows) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__SetNumRows`, writer, num_rows)) -} - -ipc___feather___TableWriter__Append <- function(writer, name, values) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__Append`, writer, name, values)) -} - -ipc___feather___TableWriter__Finalize <- function(writer) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__Finalize`, writer)) -} - -ipc___feather___TableWriter__Open <- function(stream) { - .Call(`_arrow_ipc___feather___TableWriter__Open`, stream) -} - -ipc___TableWriter__RecordBatch__WriteFeather <- function(writer, batch) { - invisible(.Call(`_arrow_ipc___TableWriter__RecordBatch__WriteFeather`, writer, batch)) -} - -ipc___feather___TableReader__GetDescription <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__GetDescription`, reader) -} - -ipc___feather___TableReader__HasDescription <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__HasDescription`, reader) -} - -ipc___feather___TableReader__version <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__version`, reader) -} - -ipc___feather___TableReader__num_rows <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__num_rows`, reader) -} - -ipc___feather___TableReader__num_columns <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__num_columns`, reader) -} - -ipc___feather___TableReader__GetColumnName <- function(reader, i) { - .Call(`_arrow_ipc___feather___TableReader__GetColumnName`, reader, i) -} - -ipc___feather___TableReader__GetColumn <- function(reader, i) { - .Call(`_arrow_ipc___feather___TableReader__GetColumn`, reader, i) -} - -ipc___feather___TableReader__Read <- function(reader, columns) { - .Call(`_arrow_ipc___feather___TableReader__Read`, reader, columns) -} - -ipc___feather___TableReader__Open <- function(stream) { - .Call(`_arrow_ipc___feather___TableReader__Open`, stream) -} - -Field__initialize <- function(name, field, nullable = TRUE) { - .Call(`_arrow_Field__initialize`, name, field, nullable) -} - -Field__ToString <- function(field) { - .Call(`_arrow_Field__ToString`, field) -} - -Field__name <- function(field) { - .Call(`_arrow_Field__name`, field) -} - -Field__Equals <- function(field, other) { - .Call(`_arrow_Field__Equals`, field, other) -} - -Field__nullable <- function(field) { - .Call(`_arrow_Field__nullable`, field) -} - -Field__type <- function(field) { - .Call(`_arrow_Field__type`, field) -} - -io___Readable__Read <- function(x, nbytes) { - .Call(`_arrow_io___Readable__Read`, x, nbytes) -} - -io___InputStream__Close <- function(x) { - invisible(.Call(`_arrow_io___InputStream__Close`, x)) -} - -io___OutputStream__Close <- function(x) { - invisible(.Call(`_arrow_io___OutputStream__Close`, x)) -} - -io___RandomAccessFile__GetSize <- function(x) { - .Call(`_arrow_io___RandomAccessFile__GetSize`, x) -} - -io___RandomAccessFile__supports_zero_copy <- function(x) { - .Call(`_arrow_io___RandomAccessFile__supports_zero_copy`, x) -} - -io___RandomAccessFile__Seek <- function(x, position) { - invisible(.Call(`_arrow_io___RandomAccessFile__Seek`, x, position)) -} - -io___RandomAccessFile__Tell <- function(x) { - .Call(`_arrow_io___RandomAccessFile__Tell`, x) -} - -io___MemoryMappedFile__Create <- function(path, size) { - .Call(`_arrow_io___MemoryMappedFile__Create`, path, size) -} - -io___MemoryMappedFile__Open <- function(path, mode) { - .Call(`_arrow_io___MemoryMappedFile__Open`, path, mode) -} - -io___MemoryMappedFile__Resize <- function(x, size) { - invisible(.Call(`_arrow_io___MemoryMappedFile__Resize`, x, size)) -} - -io___ReadableFile__Open <- function(path) { - .Call(`_arrow_io___ReadableFile__Open`, path) -} - -io___BufferReader__initialize <- function(buffer) { - .Call(`_arrow_io___BufferReader__initialize`, buffer) -} - -io___Writable__write <- function(stream, buf) { - invisible(.Call(`_arrow_io___Writable__write`, stream, buf)) -} - -io___OutputStream__Tell <- function(stream) { - .Call(`_arrow_io___OutputStream__Tell`, stream) -} - -io___FileOutputStream__Open <- function(path) { - .Call(`_arrow_io___FileOutputStream__Open`, path) -} - -io___BufferOutputStream__Create <- function(initial_capacity) { - .Call(`_arrow_io___BufferOutputStream__Create`, initial_capacity) -} - -io___BufferOutputStream__capacity <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__capacity`, stream) -} - -io___BufferOutputStream__Finish <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__Finish`, stream) -} - -io___BufferOutputStream__Tell <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__Tell`, stream) -} - -io___BufferOutputStream__Write <- function(stream, bytes) { - invisible(.Call(`_arrow_io___BufferOutputStream__Write`, stream, bytes)) -} - -io___MockOutputStream__initialize <- function() { - .Call(`_arrow_io___MockOutputStream__initialize`) -} - -io___MockOutputStream__GetExtentBytesWritten <- function(stream) { - .Call(`_arrow_io___MockOutputStream__GetExtentBytesWritten`, stream) -} - -io___FixedSizeBufferWriter__initialize <- function(buffer) { - .Call(`_arrow_io___FixedSizeBufferWriter__initialize`, buffer) -} - -MemoryPool__default <- function() { - .Call(`_arrow_MemoryPool__default`) -} - -MemoryPool__bytes_allocated <- function(pool) { - .Call(`_arrow_MemoryPool__bytes_allocated`, pool) -} - -MemoryPool__max_memory <- function(pool) { - .Call(`_arrow_MemoryPool__max_memory`, pool) -} - -ipc___Message__body_length <- function(message) { - .Call(`_arrow_ipc___Message__body_length`, message) -} - -ipc___Message__metadata <- function(message) { - .Call(`_arrow_ipc___Message__metadata`, message) -} - -ipc___Message__body <- function(message) { - .Call(`_arrow_ipc___Message__body`, message) -} - -ipc___Message__Verify <- function(message) { - .Call(`_arrow_ipc___Message__Verify`, message) -} - -ipc___Message__type <- function(message) { - .Call(`_arrow_ipc___Message__type`, message) -} - -ipc___Message__Equals <- function(x, y) { - .Call(`_arrow_ipc___Message__Equals`, x, y) -} - -ipc___ReadRecordBatch__Message__Schema <- function(message, schema) { - .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema`, message, schema) -} - -ipc___ReadSchema_InputStream <- function(stream) { - .Call(`_arrow_ipc___ReadSchema_InputStream`, stream) -} - -ipc___MessageReader__Open <- function(stream) { - .Call(`_arrow_ipc___MessageReader__Open`, stream) -} - -ipc___MessageReader__ReadNextMessage <- function(reader) { - .Call(`_arrow_ipc___MessageReader__ReadNextMessage`, reader) -} - -ipc___ReadMessage <- function(stream) { - .Call(`_arrow_ipc___ReadMessage`, stream) -} - -read_parquet_file <- function(filename) { - .Call(`_arrow_read_parquet_file`, filename) -} - -RecordBatch__num_columns <- function(x) { - .Call(`_arrow_RecordBatch__num_columns`, x) -} - -RecordBatch__num_rows <- function(x) { - .Call(`_arrow_RecordBatch__num_rows`, x) -} - -RecordBatch__schema <- function(x) { - .Call(`_arrow_RecordBatch__schema`, x) -} - -RecordBatch__columns <- function(batch) { - .Call(`_arrow_RecordBatch__columns`, batch) -} - -RecordBatch__column <- function(batch, i) { - .Call(`_arrow_RecordBatch__column`, batch, i) -} - -RecordBatch__Equals <- function(self, other) { - .Call(`_arrow_RecordBatch__Equals`, self, other) -} - -RecordBatch__RemoveColumn <- function(batch, i) { - .Call(`_arrow_RecordBatch__RemoveColumn`, batch, i) -} - -RecordBatch__column_name <- function(batch, i) { - .Call(`_arrow_RecordBatch__column_name`, batch, i) -} - -RecordBatch__names <- function(batch) { - .Call(`_arrow_RecordBatch__names`, batch) -} - -RecordBatch__Slice1 <- function(self, offset) { - .Call(`_arrow_RecordBatch__Slice1`, self, offset) -} - -RecordBatch__Slice2 <- function(self, offset, length) { - .Call(`_arrow_RecordBatch__Slice2`, self, offset, length) -} - -ipc___SerializeRecordBatch__Raw <- function(batch) { - .Call(`_arrow_ipc___SerializeRecordBatch__Raw`, batch) -} - -ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema) { - .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema`, stream, schema) -} - -RecordBatch__from_arrays <- function(schema_sxp, lst) { - .Call(`_arrow_RecordBatch__from_arrays`, schema_sxp, lst) -} - -RecordBatchReader__schema <- function(reader) { - .Call(`_arrow_RecordBatchReader__schema`, reader) -} - -RecordBatchReader__ReadNext <- function(reader) { - .Call(`_arrow_RecordBatchReader__ReadNext`, reader) -} - -ipc___RecordBatchStreamReader__Open <- function(stream) { - .Call(`_arrow_ipc___RecordBatchStreamReader__Open`, stream) -} - -ipc___RecordBatchStreamReader__batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchStreamReader__batches`, reader) -} - -ipc___RecordBatchFileReader__schema <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__schema`, reader) -} - -ipc___RecordBatchFileReader__num_record_batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches`, reader) -} - -ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i) { - .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch`, reader, i) -} - -ipc___RecordBatchFileReader__Open <- function(file) { - .Call(`_arrow_ipc___RecordBatchFileReader__Open`, file) -} - -Table__from_RecordBatchFileReader <- function(reader) { - .Call(`_arrow_Table__from_RecordBatchFileReader`, reader) -} - -Table__from_RecordBatchStreamReader <- function(reader) { - .Call(`_arrow_Table__from_RecordBatchStreamReader`, reader) -} - -ipc___RecordBatchFileReader__batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__batches`, reader) -} - -ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch`, batch_writer, batch)) -} - -ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable`, batch_writer, table)) -} - -ipc___RecordBatchWriter__Close <- function(batch_writer) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close`, batch_writer)) -} - -ipc___RecordBatchFileWriter__Open <- function(stream, schema) { - .Call(`_arrow_ipc___RecordBatchFileWriter__Open`, stream, schema) -} - -ipc___RecordBatchStreamWriter__Open <- function(stream, schema) { - .Call(`_arrow_ipc___RecordBatchStreamWriter__Open`, stream, schema) -} - -Table__num_columns <- function(x) { - .Call(`_arrow_Table__num_columns`, x) -} - -Table__num_rows <- function(x) { - .Call(`_arrow_Table__num_rows`, x) -} - -Table__schema <- function(x) { - .Call(`_arrow_Table__schema`, x) -} - -Table__column <- function(table, i) { - .Call(`_arrow_Table__column`, table, i) -} - -Table__columns <- function(table) { - .Call(`_arrow_Table__columns`, table) -} - -Table__from_dots <- function(lst, schema_sxp) { - .Call(`_arrow_Table__from_dots`, lst, schema_sxp) -} - -#' View and manage the capacity of the global thread pool -#' -#' `GetCpuThreadPoolCapacity()` returns the number of worker threads in the -#' thread pool to which -#' Arrow dispatches various CPU-bound tasks. This is an ideal number, -#' not necessarily the exact number of threads at a given point in time. -#' You can change this number using `SetCpuThreadPoolCapacity()`. -#' -#' @param threads the number of worker threads in the thread pool to which -#' Arrow dispatches various CPU-bound tasks. -#' -#' @return `GetCpuThreadPoolCapacity()` returns the number of worker threads. -#' `SetCpuThreadPoolCapacity()` returns nothing. -#' @export -#' @name threadpool -GetCpuThreadPoolCapacity <- function() { - .Call(`_arrow_GetCpuThreadPoolCapacity`) -} - -#' @rdname threadpool -#' @export -SetCpuThreadPoolCapacity <- function(threads) { - invisible(.Call(`_arrow_SetCpuThreadPoolCapacity`, threads)) -} - diff --git a/r/R/generated.R b/r/R/generated.R new file mode 100644 index 00000000000..1fa537ef5a9 --- /dev/null +++ b/r/R/generated.R @@ -0,0 +1,831 @@ +# Generated by using data-raw/codegen.R -> do not edit by hand + +Array__Slice1 <- function(array, offset) { + .Call(`_arrow_Array__Slice1` , array, offset ) +} + +Array__Slice2 <- function(array, offset, length) { + .Call(`_arrow_Array__Slice2` , array, offset, length ) +} + +Array__IsNull <- function(x, i) { + .Call(`_arrow_Array__IsNull` , x, i ) +} + +Array__IsValid <- function(x, i) { + .Call(`_arrow_Array__IsValid` , x, i ) +} + +Array__length <- function(x) { + .Call(`_arrow_Array__length` , x ) +} + +Array__offset <- function(x) { + .Call(`_arrow_Array__offset` , x ) +} + +Array__null_count <- function(x) { + .Call(`_arrow_Array__null_count` , x ) +} + +Array__type <- function(x) { + .Call(`_arrow_Array__type` , x ) +} + +Array__ToString <- function(x) { + .Call(`_arrow_Array__ToString` , x ) +} + +Array__type_id <- function(x) { + .Call(`_arrow_Array__type_id` , x ) +} + +Array__Equals <- function(lhs, rhs) { + .Call(`_arrow_Array__Equals` , lhs, rhs ) +} + +Array__ApproxEquals <- function(lhs, rhs) { + .Call(`_arrow_Array__ApproxEquals` , lhs, rhs ) +} + +Array__data <- function(array) { + .Call(`_arrow_Array__data` , array ) +} + +Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx) { + .Call(`_arrow_Array__RangeEquals` , self, other, start_idx, end_idx, other_start_idx ) +} + +Array__Mask <- function(array) { + .Call(`_arrow_Array__Mask` , array ) +} + +DictionaryArray__indices <- function(array) { + .Call(`_arrow_DictionaryArray__indices` , array ) +} + +DictionaryArray__dictionary <- function(array) { + .Call(`_arrow_DictionaryArray__dictionary` , array ) +} + +Array__as_vector <- function(array) { + .Call(`_arrow_Array__as_vector` , array ) +} + +ChunkedArray__as_vector <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__as_vector` , chunked_array ) +} + +RecordBatch__to_dataframe <- function(batch, use_threads) { + .Call(`_arrow_RecordBatch__to_dataframe` , batch, use_threads ) +} + +Table__to_dataframe <- function(table, use_threads) { + .Call(`_arrow_Table__to_dataframe` , table, use_threads ) +} + +Array__infer_type <- function(x) { + .Call(`_arrow_Array__infer_type` , x ) +} + +Array__from_vector <- function(x, s_type) { + .Call(`_arrow_Array__from_vector` , x, s_type ) +} + +ChunkedArray__from_list <- function(chunks, s_type) { + .Call(`_arrow_ChunkedArray__from_list` , chunks, s_type ) +} + +ArrayData__get_type <- function(x) { + .Call(`_arrow_ArrayData__get_type` , x ) +} + +ArrayData__get_length <- function(x) { + .Call(`_arrow_ArrayData__get_length` , x ) +} + +ArrayData__get_null_count <- function(x) { + .Call(`_arrow_ArrayData__get_null_count` , x ) +} + +ArrayData__get_offset <- function(x) { + .Call(`_arrow_ArrayData__get_offset` , x ) +} + +ArrayData__buffers <- function(x) { + .Call(`_arrow_ArrayData__buffers` , x ) +} + +Buffer__is_mutable <- function(buffer) { + .Call(`_arrow_Buffer__is_mutable` , buffer ) +} + +Buffer__ZeroPadding <- function(buffer) { + invisible(.Call(`_arrow_Buffer__ZeroPadding` , buffer )) +} + +Buffer__capacity <- function(buffer) { + .Call(`_arrow_Buffer__capacity` , buffer ) +} + +Buffer__size <- function(buffer) { + .Call(`_arrow_Buffer__size` , buffer ) +} + +r___RBuffer__initialize <- function(x) { + .Call(`_arrow_r___RBuffer__initialize` , x ) +} + +ChunkedArray__length <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__length` , chunked_array ) +} + +ChunkedArray__null_count <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__null_count` , chunked_array ) +} + +ChunkedArray__num_chunks <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__num_chunks` , chunked_array ) +} + +ChunkedArray__chunk <- function(chunked_array, i) { + .Call(`_arrow_ChunkedArray__chunk` , chunked_array, i ) +} + +ChunkedArray__chunks <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__chunks` , chunked_array ) +} + +ChunkedArray__type <- function(chunked_array) { + .Call(`_arrow_ChunkedArray__type` , chunked_array ) +} + +ChunkArray__Slice1 <- function(chunked_array, offset) { + .Call(`_arrow_ChunkArray__Slice1` , chunked_array, offset ) +} + +ChunkArray__Slice2 <- function(chunked_array, offset, length) { + .Call(`_arrow_ChunkArray__Slice2` , chunked_array, offset, length ) +} + +Column__length <- function(column) { + .Call(`_arrow_Column__length` , column ) +} + +Column__null_count <- function(column) { + .Call(`_arrow_Column__null_count` , column ) +} + +Column__type <- function(column) { + .Call(`_arrow_Column__type` , column ) +} + +Column__data <- function(column) { + .Call(`_arrow_Column__data` , column ) +} + +util___Codec__Create <- function(codec) { + .Call(`_arrow_util___Codec__Create` , codec ) +} + +io___CompressedOutputStream__Make <- function(codec, raw) { + .Call(`_arrow_io___CompressedOutputStream__Make` , codec, raw ) +} + +io___CompressedInputStream__Make <- function(codec, raw) { + .Call(`_arrow_io___CompressedInputStream__Make` , codec, raw ) +} + +compute___CastOptions__initialize <- function(allow_int_overflow, allow_time_truncate, allow_float_truncate) { + .Call(`_arrow_compute___CastOptions__initialize` , allow_int_overflow, allow_time_truncate, allow_float_truncate ) +} + +Array__cast <- function(array, target_type, options) { + .Call(`_arrow_Array__cast` , array, target_type, options ) +} + +ChunkedArray__cast <- function(chunked_array, target_type, options) { + .Call(`_arrow_ChunkedArray__cast` , chunked_array, target_type, options ) +} + +RecordBatch__cast <- function(batch, schema, options) { + .Call(`_arrow_RecordBatch__cast` , batch, schema, options ) +} + +Table__cast <- function(table, schema, options) { + .Call(`_arrow_Table__cast` , table, schema, options ) +} + +csv___ReadOptions__initialize <- function(options) { + .Call(`_arrow_csv___ReadOptions__initialize` , options ) +} + +csv___ParseOptions__initialize <- function(options) { + .Call(`_arrow_csv___ParseOptions__initialize` , options ) +} + +csv___ConvertOptions__initialize <- function(options) { + .Call(`_arrow_csv___ConvertOptions__initialize` , options ) +} + +csv___TableReader__Make <- function(input, read_options, parse_options, convert_options) { + .Call(`_arrow_csv___TableReader__Make` , input, read_options, parse_options, convert_options ) +} + +csv___TableReader__Read <- function(table_reader) { + .Call(`_arrow_csv___TableReader__Read` , table_reader ) +} + +shared_ptr_is_null <- function(xp) { + .Call(`_arrow_shared_ptr_is_null` , xp ) +} + +unique_ptr_is_null <- function(xp) { + .Call(`_arrow_unique_ptr_is_null` , xp ) +} + +Int8__initialize <- function() { + .Call(`_arrow_Int8__initialize` ) +} + +Int16__initialize <- function() { + .Call(`_arrow_Int16__initialize` ) +} + +Int32__initialize <- function() { + .Call(`_arrow_Int32__initialize` ) +} + +Int64__initialize <- function() { + .Call(`_arrow_Int64__initialize` ) +} + +UInt8__initialize <- function() { + .Call(`_arrow_UInt8__initialize` ) +} + +UInt16__initialize <- function() { + .Call(`_arrow_UInt16__initialize` ) +} + +UInt32__initialize <- function() { + .Call(`_arrow_UInt32__initialize` ) +} + +UInt64__initialize <- function() { + .Call(`_arrow_UInt64__initialize` ) +} + +Float16__initialize <- function() { + .Call(`_arrow_Float16__initialize` ) +} + +Float32__initialize <- function() { + .Call(`_arrow_Float32__initialize` ) +} + +Float64__initialize <- function() { + .Call(`_arrow_Float64__initialize` ) +} + +Boolean__initialize <- function() { + .Call(`_arrow_Boolean__initialize` ) +} + +Utf8__initialize <- function() { + .Call(`_arrow_Utf8__initialize` ) +} + +Date32__initialize <- function() { + .Call(`_arrow_Date32__initialize` ) +} + +Date64__initialize <- function() { + .Call(`_arrow_Date64__initialize` ) +} + +Null__initialize <- function() { + .Call(`_arrow_Null__initialize` ) +} + +Decimal128Type__initialize <- function(precision, scale) { + .Call(`_arrow_Decimal128Type__initialize` , precision, scale ) +} + +FixedSizeBinary__initialize <- function(byte_width) { + .Call(`_arrow_FixedSizeBinary__initialize` , byte_width ) +} + +Timestamp__initialize1 <- function(unit) { + .Call(`_arrow_Timestamp__initialize1` , unit ) +} + +Timestamp__initialize2 <- function(unit, timezone) { + .Call(`_arrow_Timestamp__initialize2` , unit, timezone ) +} + +Time32__initialize <- function(unit) { + .Call(`_arrow_Time32__initialize` , unit ) +} + +Time64__initialize <- function(unit) { + .Call(`_arrow_Time64__initialize` , unit ) +} + +list__ <- function(x) { + .Call(`_arrow_list__` , x ) +} + +struct_ <- function(fields) { + .Call(`_arrow_struct_` , fields ) +} + +DataType__ToString <- function(type) { + .Call(`_arrow_DataType__ToString` , type ) +} + +DataType__name <- function(type) { + .Call(`_arrow_DataType__name` , type ) +} + +DataType__Equals <- function(lhs, rhs) { + .Call(`_arrow_DataType__Equals` , lhs, rhs ) +} + +DataType__num_children <- function(type) { + .Call(`_arrow_DataType__num_children` , type ) +} + +DataType__children_pointer <- function(type) { + .Call(`_arrow_DataType__children_pointer` , type ) +} + +DataType__id <- function(type) { + .Call(`_arrow_DataType__id` , type ) +} + +schema_ <- function(fields) { + .Call(`_arrow_schema_` , fields ) +} + +Schema__ToString <- function(s) { + .Call(`_arrow_Schema__ToString` , s ) +} + +Schema__num_fields <- function(s) { + .Call(`_arrow_Schema__num_fields` , s ) +} + +Schema__field <- function(s, i) { + .Call(`_arrow_Schema__field` , s, i ) +} + +Schema__names <- function(schema) { + .Call(`_arrow_Schema__names` , schema ) +} + +ListType__ToString <- function(type) { + .Call(`_arrow_ListType__ToString` , type ) +} + +FixedWidthType__bit_width <- function(type) { + .Call(`_arrow_FixedWidthType__bit_width` , type ) +} + +DateType__unit <- function(type) { + .Call(`_arrow_DateType__unit` , type ) +} + +TimeType__unit <- function(type) { + .Call(`_arrow_TimeType__unit` , type ) +} + +DecimalType__precision <- function(type) { + .Call(`_arrow_DecimalType__precision` , type ) +} + +DecimalType__scale <- function(type) { + .Call(`_arrow_DecimalType__scale` , type ) +} + +TimestampType__timezone <- function(type) { + .Call(`_arrow_TimestampType__timezone` , type ) +} + +TimestampType__unit <- function(type) { + .Call(`_arrow_TimestampType__unit` , type ) +} + +DictionaryType__initialize <- function(index_type, value_type, ordered) { + .Call(`_arrow_DictionaryType__initialize` , index_type, value_type, ordered ) +} + +DictionaryType__index_type <- function(type) { + .Call(`_arrow_DictionaryType__index_type` , type ) +} + +DictionaryType__value_type <- function(type) { + .Call(`_arrow_DictionaryType__value_type` , type ) +} + +DictionaryType__name <- function(type) { + .Call(`_arrow_DictionaryType__name` , type ) +} + +DictionaryType__ordered <- function(type) { + .Call(`_arrow_DictionaryType__ordered` , type ) +} + +ipc___feather___TableWriter__SetDescription <- function(writer, description) { + invisible(.Call(`_arrow_ipc___feather___TableWriter__SetDescription` , writer, description )) +} + +ipc___feather___TableWriter__SetNumRows <- function(writer, num_rows) { + invisible(.Call(`_arrow_ipc___feather___TableWriter__SetNumRows` , writer, num_rows )) +} + +ipc___feather___TableWriter__Append <- function(writer, name, values) { + invisible(.Call(`_arrow_ipc___feather___TableWriter__Append` , writer, name, values )) +} + +ipc___feather___TableWriter__Finalize <- function(writer) { + invisible(.Call(`_arrow_ipc___feather___TableWriter__Finalize` , writer )) +} + +ipc___feather___TableWriter__Open <- function(stream) { + .Call(`_arrow_ipc___feather___TableWriter__Open` , stream ) +} + +ipc___TableWriter__RecordBatch__WriteFeather <- function(writer, batch) { + invisible(.Call(`_arrow_ipc___TableWriter__RecordBatch__WriteFeather` , writer, batch )) +} + +ipc___feather___TableReader__GetDescription <- function(reader) { + .Call(`_arrow_ipc___feather___TableReader__GetDescription` , reader ) +} + +ipc___feather___TableReader__HasDescription <- function(reader) { + .Call(`_arrow_ipc___feather___TableReader__HasDescription` , reader ) +} + +ipc___feather___TableReader__version <- function(reader) { + .Call(`_arrow_ipc___feather___TableReader__version` , reader ) +} + +ipc___feather___TableReader__num_rows <- function(reader) { + .Call(`_arrow_ipc___feather___TableReader__num_rows` , reader ) +} + +ipc___feather___TableReader__num_columns <- function(reader) { + .Call(`_arrow_ipc___feather___TableReader__num_columns` , reader ) +} + +ipc___feather___TableReader__GetColumnName <- function(reader, i) { + .Call(`_arrow_ipc___feather___TableReader__GetColumnName` , reader, i ) +} + +ipc___feather___TableReader__GetColumn <- function(reader, i) { + .Call(`_arrow_ipc___feather___TableReader__GetColumn` , reader, i ) +} + +ipc___feather___TableReader__Read <- function(reader, columns) { + .Call(`_arrow_ipc___feather___TableReader__Read` , reader, columns ) +} + +ipc___feather___TableReader__Open <- function(stream) { + .Call(`_arrow_ipc___feather___TableReader__Open` , stream ) +} + +Field__initialize <- function(name, field, nullable) { + .Call(`_arrow_Field__initialize` , name, field, nullable ) +} + +Field__ToString <- function(field) { + .Call(`_arrow_Field__ToString` , field ) +} + +Field__name <- function(field) { + .Call(`_arrow_Field__name` , field ) +} + +Field__Equals <- function(field, other) { + .Call(`_arrow_Field__Equals` , field, other ) +} + +Field__nullable <- function(field) { + .Call(`_arrow_Field__nullable` , field ) +} + +Field__type <- function(field) { + .Call(`_arrow_Field__type` , field ) +} + +io___Readable__Read <- function(x, nbytes) { + .Call(`_arrow_io___Readable__Read` , x, nbytes ) +} + +io___InputStream__Close <- function(x) { + invisible(.Call(`_arrow_io___InputStream__Close` , x )) +} + +io___OutputStream__Close <- function(x) { + invisible(.Call(`_arrow_io___OutputStream__Close` , x )) +} + +io___RandomAccessFile__GetSize <- function(x) { + .Call(`_arrow_io___RandomAccessFile__GetSize` , x ) +} + +io___RandomAccessFile__supports_zero_copy <- function(x) { + .Call(`_arrow_io___RandomAccessFile__supports_zero_copy` , x ) +} + +io___RandomAccessFile__Seek <- function(x, position) { + invisible(.Call(`_arrow_io___RandomAccessFile__Seek` , x, position )) +} + +io___RandomAccessFile__Tell <- function(x) { + .Call(`_arrow_io___RandomAccessFile__Tell` , x ) +} + +io___MemoryMappedFile__Create <- function(path, size) { + .Call(`_arrow_io___MemoryMappedFile__Create` , path, size ) +} + +io___MemoryMappedFile__Open <- function(path, mode) { + .Call(`_arrow_io___MemoryMappedFile__Open` , path, mode ) +} + +io___MemoryMappedFile__Resize <- function(x, size) { + invisible(.Call(`_arrow_io___MemoryMappedFile__Resize` , x, size )) +} + +io___ReadableFile__Open <- function(path) { + .Call(`_arrow_io___ReadableFile__Open` , path ) +} + +io___BufferReader__initialize <- function(buffer) { + .Call(`_arrow_io___BufferReader__initialize` , buffer ) +} + +io___Writable__write <- function(stream, buf) { + invisible(.Call(`_arrow_io___Writable__write` , stream, buf )) +} + +io___OutputStream__Tell <- function(stream) { + .Call(`_arrow_io___OutputStream__Tell` , stream ) +} + +io___FileOutputStream__Open <- function(path) { + .Call(`_arrow_io___FileOutputStream__Open` , path ) +} + +io___BufferOutputStream__Create <- function(initial_capacity) { + .Call(`_arrow_io___BufferOutputStream__Create` , initial_capacity ) +} + +io___BufferOutputStream__capacity <- function(stream) { + .Call(`_arrow_io___BufferOutputStream__capacity` , stream ) +} + +io___BufferOutputStream__Finish <- function(stream) { + .Call(`_arrow_io___BufferOutputStream__Finish` , stream ) +} + +io___BufferOutputStream__Tell <- function(stream) { + .Call(`_arrow_io___BufferOutputStream__Tell` , stream ) +} + +io___BufferOutputStream__Write <- function(stream, bytes) { + invisible(.Call(`_arrow_io___BufferOutputStream__Write` , stream, bytes )) +} + +io___MockOutputStream__initialize <- function() { + .Call(`_arrow_io___MockOutputStream__initialize` ) +} + +io___MockOutputStream__GetExtentBytesWritten <- function(stream) { + .Call(`_arrow_io___MockOutputStream__GetExtentBytesWritten` , stream ) +} + +io___FixedSizeBufferWriter__initialize <- function(buffer) { + .Call(`_arrow_io___FixedSizeBufferWriter__initialize` , buffer ) +} + +MemoryPool__default <- function() { + .Call(`_arrow_MemoryPool__default` ) +} + +MemoryPool__bytes_allocated <- function(pool) { + .Call(`_arrow_MemoryPool__bytes_allocated` , pool ) +} + +MemoryPool__max_memory <- function(pool) { + .Call(`_arrow_MemoryPool__max_memory` , pool ) +} + +ipc___Message__body_length <- function(message) { + .Call(`_arrow_ipc___Message__body_length` , message ) +} + +ipc___Message__metadata <- function(message) { + .Call(`_arrow_ipc___Message__metadata` , message ) +} + +ipc___Message__body <- function(message) { + .Call(`_arrow_ipc___Message__body` , message ) +} + +ipc___Message__Verify <- function(message) { + .Call(`_arrow_ipc___Message__Verify` , message ) +} + +ipc___Message__type <- function(message) { + .Call(`_arrow_ipc___Message__type` , message ) +} + +ipc___Message__Equals <- function(x, y) { + .Call(`_arrow_ipc___Message__Equals` , x, y ) +} + +ipc___ReadRecordBatch__Message__Schema <- function(message, schema) { + .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema` , message, schema ) +} + +ipc___ReadSchema_InputStream <- function(stream) { + .Call(`_arrow_ipc___ReadSchema_InputStream` , stream ) +} + +ipc___MessageReader__Open <- function(stream) { + .Call(`_arrow_ipc___MessageReader__Open` , stream ) +} + +ipc___MessageReader__ReadNextMessage <- function(reader) { + .Call(`_arrow_ipc___MessageReader__ReadNextMessage` , reader ) +} + +ipc___ReadMessage <- function(stream) { + .Call(`_arrow_ipc___ReadMessage` , stream ) +} + +read_parquet_file <- function(filename) { + .Call(`_arrow_read_parquet_file` , filename ) +} + +RecordBatch__num_columns <- function(x) { + .Call(`_arrow_RecordBatch__num_columns` , x ) +} + +RecordBatch__num_rows <- function(x) { + .Call(`_arrow_RecordBatch__num_rows` , x ) +} + +RecordBatch__schema <- function(x) { + .Call(`_arrow_RecordBatch__schema` , x ) +} + +RecordBatch__columns <- function(batch) { + .Call(`_arrow_RecordBatch__columns` , batch ) +} + +RecordBatch__column <- function(batch, i) { + .Call(`_arrow_RecordBatch__column` , batch, i ) +} + +RecordBatch__from_dataframe <- function(tbl) { + .Call(`_arrow_RecordBatch__from_dataframe` , tbl ) +} + +RecordBatch__Equals <- function(self, other) { + .Call(`_arrow_RecordBatch__Equals` , self, other ) +} + +RecordBatch__RemoveColumn <- function(batch, i) { + .Call(`_arrow_RecordBatch__RemoveColumn` , batch, i ) +} + +RecordBatch__column_name <- function(batch, i) { + .Call(`_arrow_RecordBatch__column_name` , batch, i ) +} + +RecordBatch__names <- function(batch) { + .Call(`_arrow_RecordBatch__names` , batch ) +} + +RecordBatch__Slice1 <- function(self, offset) { + .Call(`_arrow_RecordBatch__Slice1` , self, offset ) +} + +RecordBatch__Slice2 <- function(self, offset, length) { + .Call(`_arrow_RecordBatch__Slice2` , self, offset, length ) +} + +ipc___SerializeRecordBatch__Raw <- function(batch) { + .Call(`_arrow_ipc___SerializeRecordBatch__Raw` , batch ) +} + +ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema) { + .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema` , stream, schema ) +} + +RecordBatchReader__schema <- function(reader) { + .Call(`_arrow_RecordBatchReader__schema` , reader ) +} + +RecordBatchReader__ReadNext <- function(reader) { + .Call(`_arrow_RecordBatchReader__ReadNext` , reader ) +} + +ipc___RecordBatchStreamReader__Open <- function(stream) { + .Call(`_arrow_ipc___RecordBatchStreamReader__Open` , stream ) +} + +ipc___RecordBatchStreamReader__batches <- function(reader) { + .Call(`_arrow_ipc___RecordBatchStreamReader__batches` , reader ) +} + +ipc___RecordBatchFileReader__schema <- function(reader) { + .Call(`_arrow_ipc___RecordBatchFileReader__schema` , reader ) +} + +ipc___RecordBatchFileReader__num_record_batches <- function(reader) { + .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches` , reader ) +} + +ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i) { + .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch` , reader, i ) +} + +ipc___RecordBatchFileReader__Open <- function(file) { + .Call(`_arrow_ipc___RecordBatchFileReader__Open` , file ) +} + +Table__from_RecordBatchFileReader <- function(reader) { + .Call(`_arrow_Table__from_RecordBatchFileReader` , reader ) +} + +Table__from_RecordBatchStreamReader <- function(reader) { + .Call(`_arrow_Table__from_RecordBatchStreamReader` , reader ) +} + +ipc___RecordBatchFileReader__batches <- function(reader) { + .Call(`_arrow_ipc___RecordBatchFileReader__batches` , reader ) +} + +ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch) { + invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch` , batch_writer, batch )) +} + +ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table) { + invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable` , batch_writer, table )) +} + +ipc___RecordBatchWriter__Close <- function(batch_writer) { + invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close` , batch_writer )) +} + +ipc___RecordBatchFileWriter__Open <- function(stream, schema) { + .Call(`_arrow_ipc___RecordBatchFileWriter__Open` , stream, schema ) +} + +ipc___RecordBatchStreamWriter__Open <- function(stream, schema) { + .Call(`_arrow_ipc___RecordBatchStreamWriter__Open` , stream, schema ) +} + +Table__from_dataframe <- function(tbl) { + .Call(`_arrow_Table__from_dataframe` , tbl ) +} + +Table__num_columns <- function(x) { + .Call(`_arrow_Table__num_columns` , x ) +} + +Table__num_rows <- function(x) { + .Call(`_arrow_Table__num_rows` , x ) +} + +Table__schema <- function(x) { + .Call(`_arrow_Table__schema` , x ) +} + +Table__column <- function(table, i) { + .Call(`_arrow_Table__column` , table, i ) +} + +Table__columns <- function(table) { + .Call(`_arrow_Table__columns` , table ) +} + +GetCpuThreadPoolCapacity <- function() { + .Call(`_arrow_GetCpuThreadPoolCapacity` ) +} + +SetCpuThreadPoolCapacity <- function(threads) { + invisible(.Call(`_arrow_SetCpuThreadPoolCapacity` , threads )) +} + + +arrow_available <- function() { + .Call(`_arrow_available`) +} + diff --git a/r/R/parquet.R b/r/R/parquet.R index c1265594586..699d28bf76c 100644 --- a/r/R/parquet.R +++ b/r/R/parquet.R @@ -30,7 +30,11 @@ #' @return A [arrow::Table][arrow__Table], or a `tbl_df` if `as_tibble` is #' `TRUE`. #' @examples -#' df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) +#' +#' if (arrow_available()) { +#' df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) +#' } +#' #' @export read_parquet <- function(file, as_tibble = TRUE, use_threads = TRUE, ...) { tab <- shared_ptr(`arrow::Table`, read_parquet_file(file)) diff --git a/r/R/zzz.R b/r/R/zzz.R index be952a6b4f7..eab9ad477c8 100644 --- a/r/R/zzz.R +++ b/r/R/zzz.R @@ -18,3 +18,11 @@ #' @useDynLib arrow, .registration = TRUE #' @importFrom Rcpp sourceCpp NULL + +#' Is the C++ Arrow library available +#' +#' @export +arrow_available <- function() { + .Call(`_arrow_available`) +} + diff --git a/r/configure b/r/configure index 10045d3c5ec..b548725f73a 100755 --- a/r/configure +++ b/r/configure @@ -47,7 +47,7 @@ if [ "$INCLUDE_DIR" ] || [ "$LIB_DIR" ]; then PKG_LIBS="-L$LIB_DIR $PKG_LIBS" elif [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then echo "Found pkg-config cflags and libs!" - PKG_CFLAGS=${PKGCONFIG_CFLAGS} + PKG_CFLAGS="$PKGCONFIG_CFLAGS" PKG_LIBS=${PKGCONFIG_LIBS} elif [[ "$OSTYPE" == "darwin"* ]]; then if [ "$(command -v brew)" ]; then @@ -60,12 +60,6 @@ elif [[ "$OSTYPE" == "darwin"* ]]; then PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" fi -PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_PARQUET" - -# For debugging -echo "PKG_CFLAGS=$PKG_CFLAGS" -echo "PKG_LIBS=$PKG_LIBS" - # Find compiler CXXCPP=$("${R_HOME}"/bin/R CMD config CXXCPP) CXX11FLAGS=$("${R_HOME}"/bin/R CMD config CXX11FLAGS) @@ -90,9 +84,17 @@ if [ $? -ne 0 ]; then echo "is unavailable you can set INCLUDE_DIR and LIB_DIR manually via:" echo "R CMD INSTALL --configure-vars='INCLUDE_DIR=... LIB_DIR=...'" echo "--------------------------------------------------------------------" - exit 1; + + PKG_LIBS="" + PKG_CFLAGS="" +else + PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_ARROW -DARROW_R_WITH_PARQUET" fi +# For debugging +echo "PKG_CFLAGS=$PKG_CFLAGS" +echo "PKG_LIBS=$PKG_LIBS" + # Write to Makevars sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R new file mode 100644 index 00000000000..db35c6b13a3 --- /dev/null +++ b/r/data-raw/codegen.R @@ -0,0 +1,160 @@ +# pak::pkg_install("romainfrancois/decor") +library(decor) + +# pak::pkg_install("romainfrancois/rap") +library(rap) + +library(dplyr) +library(stringr) +library(purrr) +library(glue) + +decorations <- cpp_decorations() %>% + filter(decoration == "arrow::export") %>% + rap( ~ decor:::parse_cpp_function(context)) + +glue_collapse_or_empty <- function(...) { + res <- glue_collapse(...) + if(length(res)) { + res + } else { + "" + } +} + +sexp_params <- function(args){ + glue_collapse_or_empty(glue_data(args, "SEXP {name}_sexp"), sep = ", ") +} + +real_params <- function(args){ + glue_collapse_or_empty(glue_data(args, "{type} {name}"), sep = ", ") +} + +input_params <- function(args) { + glue_collapse_or_empty( + glue_data(args, "Rcpp::traits::input_parameter<{type}>::type {name}({name}_sexp);"), + sep = "\n" + ) +} + +list_params <- function(args) { + glue_collapse_or_empty( + glue_data(args, "{name}"), + sep = ", " + ) +} + +wrap_call <- function(name, return_type, args) { + call <- glue::glue('{name}( {list_params(args)})') + if(return_type == "void") { + glue::glue("{call};\n return R_NilValue;") + } else { + glue::glue("Rcpp::Shield rcpp_result_gen(Rcpp::wrap({call}));\n return rcpp_result_gen;") + } +} + +cpp_function_definitions <- function(name, return_type, args) { + glue::glue( + ' + #if defined(ARROW_R_WITH_ARROW) + {return_type} {name}({real_params(args)}); + SEXP _arrow_{name}({sexp_params(args)}){{ + BEGIN_RCPP + {input_params(args)}{wrap_call(name, return_type, args)} + END_RCPP + }} + #else + SEXP _arrow_{name}({sexp_params(args)}){{ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP + }} + #endif + + ', + sep = "\n" + ) +} + +definitions <- wap(decorations, + character() ~ cpp_function_definitions(name, return_type, args) +) %>% + glue_collapse(sep = "\n") + +registration <- wap(decorations, + character() ~ glue('\t\t{{ "_arrow_{name}", (DL_FUNC)& _arrow_{name}, {nrow(args)} }}, ') +) %>% + glue_collapse(sep = "\n") + + +writeLines(glue::glue(' +// Generated by using data-raw/codegen.R -> do not edit by hand +#include "./arrow_types.h" +#include + +using namespace Rcpp; + +{definitions} + +extern "C" SEXP _arrow_available() {{ +return Rf_ScalarLogical( +#if defined(ARROW_R_WITH_ARROW) + TRUE +#else + FALSE +#endif +); +}} + +static const R_CallMethodDef arrow_CallEntries[] = {{ +\t\t{{ "_arrow_available", (DL_FUNC)& _arrow_available, 0 }}, +{registration} +\t\t{{NULL, NULL, 0}} +}}; + +extern "C" void R_init_arrow(DllInfo* dll){{ + R_registerRoutines(dll, NULL, arrow_CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +}} + +'), "src/generated.cpp") + + +r_function <- function(name, return_type, args) { + formals <- list_params(args) + params <- if (nrow(args)) { + paste0(", ", list_params(args)) + } else { + "" + } + call <- if(return_type == "void") { + glue::glue('invisible(.Call(`_arrow_{name}` {params} ))') + } else { + glue::glue('.Call(`_arrow_{name}` {params} )') + } + + glue::glue( + ' + {name} <- function({list_params(args)}) {{ + {call} + }} + + ', + sep = "\n" + ) +} + +rfunctions <- wap(decorations, + character() ~ r_function(name, return_type, args) +) %>% + glue_collapse(sep = "\n") + +writeLines(glue::glue(' +# Generated by using data-raw/codegen.R -> do not edit by hand + +{rfunctions} + +'), "R/generated.R") + + + diff --git a/r/man/arrow_available.Rd b/r/man/arrow_available.Rd new file mode 100644 index 00000000000..af0f93858cd --- /dev/null +++ b/r/man/arrow_available.Rd @@ -0,0 +1,11 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/zzz.R +\name{arrow_available} +\alias{arrow_available} +\title{Is the C++ Arrow library available} +\usage{ +arrow_available() +} +\description{ +Is the C++ Arrow library available +} diff --git a/r/man/field.Rd b/r/man/field.Rd index 5cbd8033875..23532967579 100644 --- a/r/man/field.Rd +++ b/r/man/field.Rd @@ -17,6 +17,9 @@ field(name, type, metadata) Factory for a \code{arrow::Field} } \examples{ -field("x", int32()) + +if(arrow_available()){ + field("x", int32()) +} } diff --git a/r/man/read_parquet.Rd b/r/man/read_parquet.Rd index 36e6428490c..256a0f2b496 100644 --- a/r/man/read_parquet.Rd +++ b/r/man/read_parquet.Rd @@ -26,5 +26,9 @@ A \link[=arrow__Table]{arrow::Table}, or a \code{tbl_df} if \code{as_tibble} is This function enables you to read Parquet files into R. } \examples{ -df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) + +if (arrow_available()) { + df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) +} + } diff --git a/r/src/RcppExports.cpp b/r/src/RcppExports.cpp deleted file mode 100644 index a92c4c8d25b..00000000000 --- a/r/src/RcppExports.cpp +++ /dev/null @@ -1,2530 +0,0 @@ -// Generated by using Rcpp::compileAttributes() -> do not edit by hand -// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 - -#include "arrow_types.h" -#include - -using namespace Rcpp; - -// Array__Slice1 -std::shared_ptr Array__Slice1(const std::shared_ptr& array, int offset); -RcppExport SEXP _arrow_Array__Slice1(SEXP arraySEXP, SEXP offsetSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - rcpp_result_gen = Rcpp::wrap(Array__Slice1(array, offset)); - return rcpp_result_gen; -END_RCPP -} -// Array__Slice2 -std::shared_ptr Array__Slice2(const std::shared_ptr& array, int offset, int length); -RcppExport SEXP _arrow_Array__Slice2(SEXP arraySEXP, SEXP offsetSEXP, SEXP lengthSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - Rcpp::traits::input_parameter< int >::type length(lengthSEXP); - rcpp_result_gen = Rcpp::wrap(Array__Slice2(array, offset, length)); - return rcpp_result_gen; -END_RCPP -} -// Array__IsNull -bool Array__IsNull(const std::shared_ptr& x, int i); -RcppExport SEXP _arrow_Array__IsNull(SEXP xSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(Array__IsNull(x, i)); - return rcpp_result_gen; -END_RCPP -} -// Array__IsValid -bool Array__IsValid(const std::shared_ptr& x, int i); -RcppExport SEXP _arrow_Array__IsValid(SEXP xSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(Array__IsValid(x, i)); - return rcpp_result_gen; -END_RCPP -} -// Array__length -int Array__length(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__length(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__length(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__offset -int Array__offset(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__offset(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__offset(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__null_count -int Array__null_count(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__null_count(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__null_count(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__type -std::shared_ptr Array__type(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__type(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__type(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__ToString -std::string Array__ToString(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__ToString(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__ToString(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__type_id -arrow::Type::type Array__type_id(const std::shared_ptr& x); -RcppExport SEXP _arrow_Array__type_id(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__type_id(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__Equals -bool Array__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -RcppExport SEXP _arrow_Array__Equals(SEXP lhsSEXP, SEXP rhsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type lhs(lhsSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type rhs(rhsSEXP); - rcpp_result_gen = Rcpp::wrap(Array__Equals(lhs, rhs)); - return rcpp_result_gen; -END_RCPP -} -// Array__ApproxEquals -bool Array__ApproxEquals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -RcppExport SEXP _arrow_Array__ApproxEquals(SEXP lhsSEXP, SEXP rhsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type lhs(lhsSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type rhs(rhsSEXP); - rcpp_result_gen = Rcpp::wrap(Array__ApproxEquals(lhs, rhs)); - return rcpp_result_gen; -END_RCPP -} -// Array__data -std::shared_ptr Array__data(const std::shared_ptr& array); -RcppExport SEXP _arrow_Array__data(SEXP arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - rcpp_result_gen = Rcpp::wrap(Array__data(array)); - return rcpp_result_gen; -END_RCPP -} -// Array__RangeEquals -bool Array__RangeEquals(const std::shared_ptr& self, const std::shared_ptr& other, int start_idx, int end_idx, int other_start_idx); -RcppExport SEXP _arrow_Array__RangeEquals(SEXP selfSEXP, SEXP otherSEXP, SEXP start_idxSEXP, SEXP end_idxSEXP, SEXP other_start_idxSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type self(selfSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type other(otherSEXP); - Rcpp::traits::input_parameter< int >::type start_idx(start_idxSEXP); - Rcpp::traits::input_parameter< int >::type end_idx(end_idxSEXP); - Rcpp::traits::input_parameter< int >::type other_start_idx(other_start_idxSEXP); - rcpp_result_gen = Rcpp::wrap(Array__RangeEquals(self, other, start_idx, end_idx, other_start_idx)); - return rcpp_result_gen; -END_RCPP -} -// Array__Mask -LogicalVector Array__Mask(const std::shared_ptr& array); -RcppExport SEXP _arrow_Array__Mask(SEXP arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - rcpp_result_gen = Rcpp::wrap(Array__Mask(array)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryArray__indices -std::shared_ptr DictionaryArray__indices(const std::shared_ptr& array); -RcppExport SEXP _arrow_DictionaryArray__indices(SEXP arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryArray__indices(array)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryArray__dictionary -std::shared_ptr DictionaryArray__dictionary(const std::shared_ptr& array); -RcppExport SEXP _arrow_DictionaryArray__dictionary(SEXP arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryArray__dictionary(array)); - return rcpp_result_gen; -END_RCPP -} -// Array__as_vector -SEXP Array__as_vector(const std::shared_ptr& array); -RcppExport SEXP _arrow_Array__as_vector(SEXP arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - rcpp_result_gen = Rcpp::wrap(Array__as_vector(array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__as_vector -SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__as_vector(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__to_dataframe -Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& batch, bool use_threads); -RcppExport SEXP _arrow_RecordBatch__to_dataframe(SEXP batchSEXP, SEXP use_threadsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - Rcpp::traits::input_parameter< bool >::type use_threads(use_threadsSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__to_dataframe(batch, use_threads)); - return rcpp_result_gen; -END_RCPP -} -// Table__to_dataframe -Rcpp::List Table__to_dataframe(const std::shared_ptr& table, bool use_threads); -RcppExport SEXP _arrow_Table__to_dataframe(SEXP tableSEXP, SEXP use_threadsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table(tableSEXP); - Rcpp::traits::input_parameter< bool >::type use_threads(use_threadsSEXP); - rcpp_result_gen = Rcpp::wrap(Table__to_dataframe(table, use_threads)); - return rcpp_result_gen; -END_RCPP -} -// Array__infer_type -std::shared_ptr Array__infer_type(SEXP x); -RcppExport SEXP _arrow_Array__infer_type(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Array__infer_type(x)); - return rcpp_result_gen; -END_RCPP -} -// Array__from_vector -std::shared_ptr Array__from_vector(SEXP x, SEXP s_type); -RcppExport SEXP _arrow_Array__from_vector(SEXP xSEXP, SEXP s_typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type x(xSEXP); - Rcpp::traits::input_parameter< SEXP >::type s_type(s_typeSEXP); - rcpp_result_gen = Rcpp::wrap(Array__from_vector(x, s_type)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__from_list -std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, SEXP s_type); -RcppExport SEXP _arrow_ChunkedArray__from_list(SEXP chunksSEXP, SEXP s_typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< Rcpp::List >::type chunks(chunksSEXP); - Rcpp::traits::input_parameter< SEXP >::type s_type(s_typeSEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__from_list(chunks, s_type)); - return rcpp_result_gen; -END_RCPP -} -// ArrayData__get_type -std::shared_ptr ArrayData__get_type(const std::shared_ptr& x); -RcppExport SEXP _arrow_ArrayData__get_type(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(ArrayData__get_type(x)); - return rcpp_result_gen; -END_RCPP -} -// ArrayData__get_length -int ArrayData__get_length(const std::shared_ptr& x); -RcppExport SEXP _arrow_ArrayData__get_length(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(ArrayData__get_length(x)); - return rcpp_result_gen; -END_RCPP -} -// ArrayData__get_null_count -int ArrayData__get_null_count(const std::shared_ptr& x); -RcppExport SEXP _arrow_ArrayData__get_null_count(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(ArrayData__get_null_count(x)); - return rcpp_result_gen; -END_RCPP -} -// ArrayData__get_offset -int ArrayData__get_offset(const std::shared_ptr& x); -RcppExport SEXP _arrow_ArrayData__get_offset(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(ArrayData__get_offset(x)); - return rcpp_result_gen; -END_RCPP -} -// ArrayData__buffers -List ArrayData__buffers(const std::shared_ptr& x); -RcppExport SEXP _arrow_ArrayData__buffers(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(ArrayData__buffers(x)); - return rcpp_result_gen; -END_RCPP -} -// Buffer__is_mutable -bool Buffer__is_mutable(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_Buffer__is_mutable(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - rcpp_result_gen = Rcpp::wrap(Buffer__is_mutable(buffer)); - return rcpp_result_gen; -END_RCPP -} -// Buffer__ZeroPadding -void Buffer__ZeroPadding(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_Buffer__ZeroPadding(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - Buffer__ZeroPadding(buffer); - return R_NilValue; -END_RCPP -} -// Buffer__capacity -int64_t Buffer__capacity(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_Buffer__capacity(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - rcpp_result_gen = Rcpp::wrap(Buffer__capacity(buffer)); - return rcpp_result_gen; -END_RCPP -} -// Buffer__size -int64_t Buffer__size(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_Buffer__size(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - rcpp_result_gen = Rcpp::wrap(Buffer__size(buffer)); - return rcpp_result_gen; -END_RCPP -} -// r___RBuffer__initialize -std::shared_ptr r___RBuffer__initialize(SEXP x); -RcppExport SEXP _arrow_r___RBuffer__initialize(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(r___RBuffer__initialize(x)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__length -int ChunkedArray__length(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__length(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__length(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__null_count -int ChunkedArray__null_count(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__null_count(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__null_count(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__num_chunks -int ChunkedArray__num_chunks(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__num_chunks(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__chunk -std::shared_ptr ChunkedArray__chunk(const std::shared_ptr& chunked_array, int i); -RcppExport SEXP _arrow_ChunkedArray__chunk(SEXP chunked_arraySEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__chunk(chunked_array, i)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__chunks -List ChunkedArray__chunks(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__chunks(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__chunks(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__type -std::shared_ptr ChunkedArray__type(const std::shared_ptr& chunked_array); -RcppExport SEXP _arrow_ChunkedArray__type(SEXP chunked_arraySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__type(chunked_array)); - return rcpp_result_gen; -END_RCPP -} -// ChunkArray__Slice1 -std::shared_ptr ChunkArray__Slice1(const std::shared_ptr& chunked_array, int offset); -RcppExport SEXP _arrow_ChunkArray__Slice1(SEXP chunked_arraySEXP, SEXP offsetSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - rcpp_result_gen = Rcpp::wrap(ChunkArray__Slice1(chunked_array, offset)); - return rcpp_result_gen; -END_RCPP -} -// ChunkArray__Slice2 -std::shared_ptr ChunkArray__Slice2(const std::shared_ptr& chunked_array, int offset, int length); -RcppExport SEXP _arrow_ChunkArray__Slice2(SEXP chunked_arraySEXP, SEXP offsetSEXP, SEXP lengthSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - Rcpp::traits::input_parameter< int >::type length(lengthSEXP); - rcpp_result_gen = Rcpp::wrap(ChunkArray__Slice2(chunked_array, offset, length)); - return rcpp_result_gen; -END_RCPP -} -// Column__length -int Column__length(const std::shared_ptr& column); -RcppExport SEXP _arrow_Column__length(SEXP columnSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type column(columnSEXP); - rcpp_result_gen = Rcpp::wrap(Column__length(column)); - return rcpp_result_gen; -END_RCPP -} -// Column__null_count -int Column__null_count(const std::shared_ptr& column); -RcppExport SEXP _arrow_Column__null_count(SEXP columnSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type column(columnSEXP); - rcpp_result_gen = Rcpp::wrap(Column__null_count(column)); - return rcpp_result_gen; -END_RCPP -} -// Column__type -std::shared_ptr Column__type(const std::shared_ptr& column); -RcppExport SEXP _arrow_Column__type(SEXP columnSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type column(columnSEXP); - rcpp_result_gen = Rcpp::wrap(Column__type(column)); - return rcpp_result_gen; -END_RCPP -} -// Column__data -std::shared_ptr Column__data(const std::shared_ptr& column); -RcppExport SEXP _arrow_Column__data(SEXP columnSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type column(columnSEXP); - rcpp_result_gen = Rcpp::wrap(Column__data(column)); - return rcpp_result_gen; -END_RCPP -} -// util___Codec__Create -std::unique_ptr util___Codec__Create(arrow::Compression::type codec); -RcppExport SEXP _arrow_util___Codec__Create(SEXP codecSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arrow::Compression::type >::type codec(codecSEXP); - rcpp_result_gen = Rcpp::wrap(util___Codec__Create(codec)); - return rcpp_result_gen; -END_RCPP -} -// io___CompressedOutputStream__Make -std::shared_ptr io___CompressedOutputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); -RcppExport SEXP _arrow_io___CompressedOutputStream__Make(SEXP codecSEXP, SEXP rawSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type codec(codecSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type raw(rawSEXP); - rcpp_result_gen = Rcpp::wrap(io___CompressedOutputStream__Make(codec, raw)); - return rcpp_result_gen; -END_RCPP -} -// io___CompressedInputStream__Make -std::shared_ptr io___CompressedInputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); -RcppExport SEXP _arrow_io___CompressedInputStream__Make(SEXP codecSEXP, SEXP rawSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type codec(codecSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type raw(rawSEXP); - rcpp_result_gen = Rcpp::wrap(io___CompressedInputStream__Make(codec, raw)); - return rcpp_result_gen; -END_RCPP -} -// compute___CastOptions__initialize -std::shared_ptr compute___CastOptions__initialize(bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate); -RcppExport SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflowSEXP, SEXP allow_time_truncateSEXP, SEXP allow_float_truncateSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< bool >::type allow_int_overflow(allow_int_overflowSEXP); - Rcpp::traits::input_parameter< bool >::type allow_time_truncate(allow_time_truncateSEXP); - Rcpp::traits::input_parameter< bool >::type allow_float_truncate(allow_float_truncateSEXP); - rcpp_result_gen = Rcpp::wrap(compute___CastOptions__initialize(allow_int_overflow, allow_time_truncate, allow_float_truncate)); - return rcpp_result_gen; -END_RCPP -} -// Array__cast -std::shared_ptr Array__cast(const std::shared_ptr& array, const std::shared_ptr& target_type, const std::shared_ptr& options); -RcppExport SEXP _arrow_Array__cast(SEXP arraySEXP, SEXP target_typeSEXP, SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type array(arraySEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type target_type(target_typeSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(Array__cast(array, target_type, options)); - return rcpp_result_gen; -END_RCPP -} -// ChunkedArray__cast -std::shared_ptr ChunkedArray__cast(const std::shared_ptr& chunked_array, const std::shared_ptr& target_type, const std::shared_ptr& options); -RcppExport SEXP _arrow_ChunkedArray__cast(SEXP chunked_arraySEXP, SEXP target_typeSEXP, SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type chunked_array(chunked_arraySEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type target_type(target_typeSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(ChunkedArray__cast(chunked_array, target_type, options)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__cast -std::shared_ptr RecordBatch__cast(const std::shared_ptr& batch, const std::shared_ptr& schema, const std::shared_ptr& options); -RcppExport SEXP _arrow_RecordBatch__cast(SEXP batchSEXP, SEXP schemaSEXP, SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__cast(batch, schema, options)); - return rcpp_result_gen; -END_RCPP -} -// Table__cast -std::shared_ptr Table__cast(const std::shared_ptr& table, const std::shared_ptr& schema, const std::shared_ptr& options); -RcppExport SEXP _arrow_Table__cast(SEXP tableSEXP, SEXP schemaSEXP, SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table(tableSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(Table__cast(table, schema, options)); - return rcpp_result_gen; -END_RCPP -} -// csv___ReadOptions__initialize -std::shared_ptr csv___ReadOptions__initialize(List_ options); -RcppExport SEXP _arrow_csv___ReadOptions__initialize(SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< List_ >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(csv___ReadOptions__initialize(options)); - return rcpp_result_gen; -END_RCPP -} -// csv___ParseOptions__initialize -std::shared_ptr csv___ParseOptions__initialize(List_ options); -RcppExport SEXP _arrow_csv___ParseOptions__initialize(SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< List_ >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(csv___ParseOptions__initialize(options)); - return rcpp_result_gen; -END_RCPP -} -// csv___ConvertOptions__initialize -std::shared_ptr csv___ConvertOptions__initialize(List_ options); -RcppExport SEXP _arrow_csv___ConvertOptions__initialize(SEXP optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< List_ >::type options(optionsSEXP); - rcpp_result_gen = Rcpp::wrap(csv___ConvertOptions__initialize(options)); - return rcpp_result_gen; -END_RCPP -} -// csv___TableReader__Make -std::shared_ptr csv___TableReader__Make(const std::shared_ptr& input, const std::shared_ptr& read_options, const std::shared_ptr& parse_options, const std::shared_ptr& convert_options); -RcppExport SEXP _arrow_csv___TableReader__Make(SEXP inputSEXP, SEXP read_optionsSEXP, SEXP parse_optionsSEXP, SEXP convert_optionsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type input(inputSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type read_options(read_optionsSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type parse_options(parse_optionsSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type convert_options(convert_optionsSEXP); - rcpp_result_gen = Rcpp::wrap(csv___TableReader__Make(input, read_options, parse_options, convert_options)); - return rcpp_result_gen; -END_RCPP -} -// csv___TableReader__Read -std::shared_ptr csv___TableReader__Read(const std::shared_ptr& table_reader); -RcppExport SEXP _arrow_csv___TableReader__Read(SEXP table_readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table_reader(table_readerSEXP); - rcpp_result_gen = Rcpp::wrap(csv___TableReader__Read(table_reader)); - return rcpp_result_gen; -END_RCPP -} -// shared_ptr_is_null -bool shared_ptr_is_null(SEXP xp); -RcppExport SEXP _arrow_shared_ptr_is_null(SEXP xpSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type xp(xpSEXP); - rcpp_result_gen = Rcpp::wrap(shared_ptr_is_null(xp)); - return rcpp_result_gen; -END_RCPP -} -// unique_ptr_is_null -bool unique_ptr_is_null(SEXP xp); -RcppExport SEXP _arrow_unique_ptr_is_null(SEXP xpSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type xp(xpSEXP); - rcpp_result_gen = Rcpp::wrap(unique_ptr_is_null(xp)); - return rcpp_result_gen; -END_RCPP -} -// Int8__initialize -std::shared_ptr Int8__initialize(); -RcppExport SEXP _arrow_Int8__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Int8__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Int16__initialize -std::shared_ptr Int16__initialize(); -RcppExport SEXP _arrow_Int16__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Int16__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Int32__initialize -std::shared_ptr Int32__initialize(); -RcppExport SEXP _arrow_Int32__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Int32__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Int64__initialize -std::shared_ptr Int64__initialize(); -RcppExport SEXP _arrow_Int64__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Int64__initialize()); - return rcpp_result_gen; -END_RCPP -} -// UInt8__initialize -std::shared_ptr UInt8__initialize(); -RcppExport SEXP _arrow_UInt8__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(UInt8__initialize()); - return rcpp_result_gen; -END_RCPP -} -// UInt16__initialize -std::shared_ptr UInt16__initialize(); -RcppExport SEXP _arrow_UInt16__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(UInt16__initialize()); - return rcpp_result_gen; -END_RCPP -} -// UInt32__initialize -std::shared_ptr UInt32__initialize(); -RcppExport SEXP _arrow_UInt32__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(UInt32__initialize()); - return rcpp_result_gen; -END_RCPP -} -// UInt64__initialize -std::shared_ptr UInt64__initialize(); -RcppExport SEXP _arrow_UInt64__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(UInt64__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Float16__initialize -std::shared_ptr Float16__initialize(); -RcppExport SEXP _arrow_Float16__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Float16__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Float32__initialize -std::shared_ptr Float32__initialize(); -RcppExport SEXP _arrow_Float32__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Float32__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Float64__initialize -std::shared_ptr Float64__initialize(); -RcppExport SEXP _arrow_Float64__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Float64__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Boolean__initialize -std::shared_ptr Boolean__initialize(); -RcppExport SEXP _arrow_Boolean__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Boolean__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Utf8__initialize -std::shared_ptr Utf8__initialize(); -RcppExport SEXP _arrow_Utf8__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Utf8__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Date32__initialize -std::shared_ptr Date32__initialize(); -RcppExport SEXP _arrow_Date32__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Date32__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Date64__initialize -std::shared_ptr Date64__initialize(); -RcppExport SEXP _arrow_Date64__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Date64__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Null__initialize -std::shared_ptr Null__initialize(); -RcppExport SEXP _arrow_Null__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(Null__initialize()); - return rcpp_result_gen; -END_RCPP -} -// Decimal128Type__initialize -std::shared_ptr Decimal128Type__initialize(int32_t precision, int32_t scale); -RcppExport SEXP _arrow_Decimal128Type__initialize(SEXP precisionSEXP, SEXP scaleSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< int32_t >::type precision(precisionSEXP); - Rcpp::traits::input_parameter< int32_t >::type scale(scaleSEXP); - rcpp_result_gen = Rcpp::wrap(Decimal128Type__initialize(precision, scale)); - return rcpp_result_gen; -END_RCPP -} -// FixedSizeBinary__initialize -std::shared_ptr FixedSizeBinary__initialize(int32_t byte_width); -RcppExport SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_widthSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< int32_t >::type byte_width(byte_widthSEXP); - rcpp_result_gen = Rcpp::wrap(FixedSizeBinary__initialize(byte_width)); - return rcpp_result_gen; -END_RCPP -} -// Timestamp__initialize1 -std::shared_ptr Timestamp__initialize1(arrow::TimeUnit::type unit); -RcppExport SEXP _arrow_Timestamp__initialize1(SEXP unitSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arrow::TimeUnit::type >::type unit(unitSEXP); - rcpp_result_gen = Rcpp::wrap(Timestamp__initialize1(unit)); - return rcpp_result_gen; -END_RCPP -} -// Timestamp__initialize2 -std::shared_ptr Timestamp__initialize2(arrow::TimeUnit::type unit, const std::string& timezone); -RcppExport SEXP _arrow_Timestamp__initialize2(SEXP unitSEXP, SEXP timezoneSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arrow::TimeUnit::type >::type unit(unitSEXP); - Rcpp::traits::input_parameter< const std::string& >::type timezone(timezoneSEXP); - rcpp_result_gen = Rcpp::wrap(Timestamp__initialize2(unit, timezone)); - return rcpp_result_gen; -END_RCPP -} -// Time32__initialize -std::shared_ptr Time32__initialize(arrow::TimeUnit::type unit); -RcppExport SEXP _arrow_Time32__initialize(SEXP unitSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arrow::TimeUnit::type >::type unit(unitSEXP); - rcpp_result_gen = Rcpp::wrap(Time32__initialize(unit)); - return rcpp_result_gen; -END_RCPP -} -// Time64__initialize -std::shared_ptr Time64__initialize(arrow::TimeUnit::type unit); -RcppExport SEXP _arrow_Time64__initialize(SEXP unitSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arrow::TimeUnit::type >::type unit(unitSEXP); - rcpp_result_gen = Rcpp::wrap(Time64__initialize(unit)); - return rcpp_result_gen; -END_RCPP -} -// list__ -SEXP list__(SEXP x); -RcppExport SEXP _arrow_list__(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(list__(x)); - return rcpp_result_gen; -END_RCPP -} -// struct_ -std::shared_ptr struct_(List fields); -RcppExport SEXP _arrow_struct_(SEXP fieldsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< List >::type fields(fieldsSEXP); - rcpp_result_gen = Rcpp::wrap(struct_(fields)); - return rcpp_result_gen; -END_RCPP -} -// DataType__ToString -std::string DataType__ToString(const std::shared_ptr& type); -RcppExport SEXP _arrow_DataType__ToString(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__ToString(type)); - return rcpp_result_gen; -END_RCPP -} -// DataType__name -std::string DataType__name(const std::shared_ptr& type); -RcppExport SEXP _arrow_DataType__name(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__name(type)); - return rcpp_result_gen; -END_RCPP -} -// DataType__Equals -bool DataType__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -RcppExport SEXP _arrow_DataType__Equals(SEXP lhsSEXP, SEXP rhsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type lhs(lhsSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type rhs(rhsSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__Equals(lhs, rhs)); - return rcpp_result_gen; -END_RCPP -} -// DataType__num_children -int DataType__num_children(const std::shared_ptr& type); -RcppExport SEXP _arrow_DataType__num_children(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__num_children(type)); - return rcpp_result_gen; -END_RCPP -} -// DataType__children_pointer -List DataType__children_pointer(const std::shared_ptr& type); -RcppExport SEXP _arrow_DataType__children_pointer(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__children_pointer(type)); - return rcpp_result_gen; -END_RCPP -} -// DataType__id -arrow::Type::type DataType__id(const std::shared_ptr& type); -RcppExport SEXP _arrow_DataType__id(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DataType__id(type)); - return rcpp_result_gen; -END_RCPP -} -// schema_ -std::shared_ptr schema_(List fields); -RcppExport SEXP _arrow_schema_(SEXP fieldsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< List >::type fields(fieldsSEXP); - rcpp_result_gen = Rcpp::wrap(schema_(fields)); - return rcpp_result_gen; -END_RCPP -} -// Schema__ToString -std::string Schema__ToString(const std::shared_ptr& s); -RcppExport SEXP _arrow_Schema__ToString(SEXP sSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type s(sSEXP); - rcpp_result_gen = Rcpp::wrap(Schema__ToString(s)); - return rcpp_result_gen; -END_RCPP -} -// Schema__num_fields -int Schema__num_fields(const std::shared_ptr& s); -RcppExport SEXP _arrow_Schema__num_fields(SEXP sSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type s(sSEXP); - rcpp_result_gen = Rcpp::wrap(Schema__num_fields(s)); - return rcpp_result_gen; -END_RCPP -} -// Schema__field -std::shared_ptr Schema__field(const std::shared_ptr& s, int i); -RcppExport SEXP _arrow_Schema__field(SEXP sSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type s(sSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(Schema__field(s, i)); - return rcpp_result_gen; -END_RCPP -} -// Schema__names -CharacterVector Schema__names(const std::shared_ptr& schema); -RcppExport SEXP _arrow_Schema__names(SEXP schemaSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - rcpp_result_gen = Rcpp::wrap(Schema__names(schema)); - return rcpp_result_gen; -END_RCPP -} -// ListType__ToString -std::string ListType__ToString(const std::shared_ptr& type); -RcppExport SEXP _arrow_ListType__ToString(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(ListType__ToString(type)); - return rcpp_result_gen; -END_RCPP -} -// FixedWidthType__bit_width -int FixedWidthType__bit_width(const std::shared_ptr& type); -RcppExport SEXP _arrow_FixedWidthType__bit_width(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(FixedWidthType__bit_width(type)); - return rcpp_result_gen; -END_RCPP -} -// DateType__unit -arrow::DateUnit DateType__unit(const std::shared_ptr& type); -RcppExport SEXP _arrow_DateType__unit(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DateType__unit(type)); - return rcpp_result_gen; -END_RCPP -} -// TimeType__unit -arrow::TimeUnit::type TimeType__unit(const std::shared_ptr& type); -RcppExport SEXP _arrow_TimeType__unit(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(TimeType__unit(type)); - return rcpp_result_gen; -END_RCPP -} -// DecimalType__precision -int32_t DecimalType__precision(const std::shared_ptr& type); -RcppExport SEXP _arrow_DecimalType__precision(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DecimalType__precision(type)); - return rcpp_result_gen; -END_RCPP -} -// DecimalType__scale -int32_t DecimalType__scale(const std::shared_ptr& type); -RcppExport SEXP _arrow_DecimalType__scale(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DecimalType__scale(type)); - return rcpp_result_gen; -END_RCPP -} -// TimestampType__timezone -std::string TimestampType__timezone(const std::shared_ptr& type); -RcppExport SEXP _arrow_TimestampType__timezone(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(TimestampType__timezone(type)); - return rcpp_result_gen; -END_RCPP -} -// TimestampType__unit -arrow::TimeUnit::type TimestampType__unit(const std::shared_ptr& type); -RcppExport SEXP _arrow_TimestampType__unit(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(TimestampType__unit(type)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryType__initialize -std::shared_ptr DictionaryType__initialize(const std::shared_ptr& index_type, const std::shared_ptr& value_type, bool ordered); -RcppExport SEXP _arrow_DictionaryType__initialize(SEXP index_typeSEXP, SEXP value_typeSEXP, SEXP orderedSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type index_type(index_typeSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type value_type(value_typeSEXP); - Rcpp::traits::input_parameter< bool >::type ordered(orderedSEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryType__initialize(index_type, value_type, ordered)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryType__index_type -std::shared_ptr DictionaryType__index_type(const std::shared_ptr& type); -RcppExport SEXP _arrow_DictionaryType__index_type(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryType__index_type(type)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryType__value_type -std::shared_ptr DictionaryType__value_type(const std::shared_ptr& type); -RcppExport SEXP _arrow_DictionaryType__value_type(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryType__value_type(type)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryType__name -std::string DictionaryType__name(const std::shared_ptr& type); -RcppExport SEXP _arrow_DictionaryType__name(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryType__name(type)); - return rcpp_result_gen; -END_RCPP -} -// DictionaryType__ordered -bool DictionaryType__ordered(const std::shared_ptr& type); -RcppExport SEXP _arrow_DictionaryType__ordered(SEXP typeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type type(typeSEXP); - rcpp_result_gen = Rcpp::wrap(DictionaryType__ordered(type)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableWriter__SetDescription -void ipc___feather___TableWriter__SetDescription(const std::unique_ptr& writer, const std::string& description); -RcppExport SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writerSEXP, SEXP descriptionSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type writer(writerSEXP); - Rcpp::traits::input_parameter< const std::string& >::type description(descriptionSEXP); - ipc___feather___TableWriter__SetDescription(writer, description); - return R_NilValue; -END_RCPP -} -// ipc___feather___TableWriter__SetNumRows -void ipc___feather___TableWriter__SetNumRows(const std::unique_ptr& writer, int64_t num_rows); -RcppExport SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writerSEXP, SEXP num_rowsSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type writer(writerSEXP); - Rcpp::traits::input_parameter< int64_t >::type num_rows(num_rowsSEXP); - ipc___feather___TableWriter__SetNumRows(writer, num_rows); - return R_NilValue; -END_RCPP -} -// ipc___feather___TableWriter__Append -void ipc___feather___TableWriter__Append(const std::unique_ptr& writer, const std::string& name, const std::shared_ptr& values); -RcppExport SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writerSEXP, SEXP nameSEXP, SEXP valuesSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type writer(writerSEXP); - Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type values(valuesSEXP); - ipc___feather___TableWriter__Append(writer, name, values); - return R_NilValue; -END_RCPP -} -// ipc___feather___TableWriter__Finalize -void ipc___feather___TableWriter__Finalize(const std::unique_ptr& writer); -RcppExport SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writerSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type writer(writerSEXP); - ipc___feather___TableWriter__Finalize(writer); - return R_NilValue; -END_RCPP -} -// ipc___feather___TableWriter__Open -std::unique_ptr ipc___feather___TableWriter__Open(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___feather___TableWriter__Open(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableWriter__Open(stream)); - return rcpp_result_gen; -END_RCPP -} -// ipc___TableWriter__RecordBatch__WriteFeather -void ipc___TableWriter__RecordBatch__WriteFeather(const std::unique_ptr& writer, const std::shared_ptr& batch); -RcppExport SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writerSEXP, SEXP batchSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type writer(writerSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - ipc___TableWriter__RecordBatch__WriteFeather(writer, batch); - return R_NilValue; -END_RCPP -} -// ipc___feather___TableReader__GetDescription -std::string ipc___feather___TableReader__GetDescription(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__GetDescription(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__HasDescription -bool ipc___feather___TableReader__HasDescription(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__HasDescription(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__version -int ipc___feather___TableReader__version(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___feather___TableReader__version(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__version(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__num_rows -int64_t ipc___feather___TableReader__num_rows(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__num_rows(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__num_columns -int64_t ipc___feather___TableReader__num_columns(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__num_columns(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__GetColumnName -std::string ipc___feather___TableReader__GetColumnName(const std::unique_ptr& reader, int i); -RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP readerSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__GetColumnName(reader, i)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__GetColumn -std::shared_ptr ipc___feather___TableReader__GetColumn(const std::unique_ptr& reader, int i); -RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP readerSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__GetColumn(reader, i)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__Read -std::shared_ptr ipc___feather___TableReader__Read(const std::unique_ptr& reader, SEXP columns); -RcppExport SEXP _arrow_ipc___feather___TableReader__Read(SEXP readerSEXP, SEXP columnsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - Rcpp::traits::input_parameter< SEXP >::type columns(columnsSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__Read(reader, columns)); - return rcpp_result_gen; -END_RCPP -} -// ipc___feather___TableReader__Open -std::unique_ptr ipc___feather___TableReader__Open(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___feather___TableReader__Open(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___feather___TableReader__Open(stream)); - return rcpp_result_gen; -END_RCPP -} -// Field__initialize -std::shared_ptr Field__initialize(const std::string& name, const std::shared_ptr& field, bool nullable); -RcppExport SEXP _arrow_Field__initialize(SEXP nameSEXP, SEXP fieldSEXP, SEXP nullableSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::string& >::type name(nameSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - Rcpp::traits::input_parameter< bool >::type nullable(nullableSEXP); - rcpp_result_gen = Rcpp::wrap(Field__initialize(name, field, nullable)); - return rcpp_result_gen; -END_RCPP -} -// Field__ToString -std::string Field__ToString(const std::shared_ptr& field); -RcppExport SEXP _arrow_Field__ToString(SEXP fieldSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - rcpp_result_gen = Rcpp::wrap(Field__ToString(field)); - return rcpp_result_gen; -END_RCPP -} -// Field__name -std::string Field__name(const std::shared_ptr& field); -RcppExport SEXP _arrow_Field__name(SEXP fieldSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - rcpp_result_gen = Rcpp::wrap(Field__name(field)); - return rcpp_result_gen; -END_RCPP -} -// Field__Equals -bool Field__Equals(const std::shared_ptr& field, const std::shared_ptr& other); -RcppExport SEXP _arrow_Field__Equals(SEXP fieldSEXP, SEXP otherSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type other(otherSEXP); - rcpp_result_gen = Rcpp::wrap(Field__Equals(field, other)); - return rcpp_result_gen; -END_RCPP -} -// Field__nullable -bool Field__nullable(const std::shared_ptr& field); -RcppExport SEXP _arrow_Field__nullable(SEXP fieldSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - rcpp_result_gen = Rcpp::wrap(Field__nullable(field)); - return rcpp_result_gen; -END_RCPP -} -// Field__type -std::shared_ptr Field__type(const std::shared_ptr& field); -RcppExport SEXP _arrow_Field__type(SEXP fieldSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type field(fieldSEXP); - rcpp_result_gen = Rcpp::wrap(Field__type(field)); - return rcpp_result_gen; -END_RCPP -} -// io___Readable__Read -std::shared_ptr io___Readable__Read(const std::shared_ptr& x, int64_t nbytes); -RcppExport SEXP _arrow_io___Readable__Read(SEXP xSEXP, SEXP nbytesSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< int64_t >::type nbytes(nbytesSEXP); - rcpp_result_gen = Rcpp::wrap(io___Readable__Read(x, nbytes)); - return rcpp_result_gen; -END_RCPP -} -// io___InputStream__Close -void io___InputStream__Close(const std::shared_ptr& x); -RcppExport SEXP _arrow_io___InputStream__Close(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - io___InputStream__Close(x); - return R_NilValue; -END_RCPP -} -// io___OutputStream__Close -void io___OutputStream__Close(const std::shared_ptr& x); -RcppExport SEXP _arrow_io___OutputStream__Close(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - io___OutputStream__Close(x); - return R_NilValue; -END_RCPP -} -// io___RandomAccessFile__GetSize -int64_t io___RandomAccessFile__GetSize(const std::shared_ptr& x); -RcppExport SEXP _arrow_io___RandomAccessFile__GetSize(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(io___RandomAccessFile__GetSize(x)); - return rcpp_result_gen; -END_RCPP -} -// io___RandomAccessFile__supports_zero_copy -bool io___RandomAccessFile__supports_zero_copy(const std::shared_ptr& x); -RcppExport SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(io___RandomAccessFile__supports_zero_copy(x)); - return rcpp_result_gen; -END_RCPP -} -// io___RandomAccessFile__Seek -void io___RandomAccessFile__Seek(const std::shared_ptr& x, int64_t position); -RcppExport SEXP _arrow_io___RandomAccessFile__Seek(SEXP xSEXP, SEXP positionSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< int64_t >::type position(positionSEXP); - io___RandomAccessFile__Seek(x, position); - return R_NilValue; -END_RCPP -} -// io___RandomAccessFile__Tell -int64_t io___RandomAccessFile__Tell(const std::shared_ptr& x); -RcppExport SEXP _arrow_io___RandomAccessFile__Tell(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(io___RandomAccessFile__Tell(x)); - return rcpp_result_gen; -END_RCPP -} -// io___MemoryMappedFile__Create -std::shared_ptr io___MemoryMappedFile__Create(const std::string& path, int64_t size); -RcppExport SEXP _arrow_io___MemoryMappedFile__Create(SEXP pathSEXP, SEXP sizeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::string& >::type path(pathSEXP); - Rcpp::traits::input_parameter< int64_t >::type size(sizeSEXP); - rcpp_result_gen = Rcpp::wrap(io___MemoryMappedFile__Create(path, size)); - return rcpp_result_gen; -END_RCPP -} -// io___MemoryMappedFile__Open -std::shared_ptr io___MemoryMappedFile__Open(const std::string& path, arrow::io::FileMode::type mode); -RcppExport SEXP _arrow_io___MemoryMappedFile__Open(SEXP pathSEXP, SEXP modeSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::string& >::type path(pathSEXP); - Rcpp::traits::input_parameter< arrow::io::FileMode::type >::type mode(modeSEXP); - rcpp_result_gen = Rcpp::wrap(io___MemoryMappedFile__Open(path, mode)); - return rcpp_result_gen; -END_RCPP -} -// io___MemoryMappedFile__Resize -void io___MemoryMappedFile__Resize(const std::shared_ptr& x, int64_t size); -RcppExport SEXP _arrow_io___MemoryMappedFile__Resize(SEXP xSEXP, SEXP sizeSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< int64_t >::type size(sizeSEXP); - io___MemoryMappedFile__Resize(x, size); - return R_NilValue; -END_RCPP -} -// io___ReadableFile__Open -std::shared_ptr io___ReadableFile__Open(const std::string& path); -RcppExport SEXP _arrow_io___ReadableFile__Open(SEXP pathSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::string& >::type path(pathSEXP); - rcpp_result_gen = Rcpp::wrap(io___ReadableFile__Open(path)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferReader__initialize -std::shared_ptr io___BufferReader__initialize(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_io___BufferReader__initialize(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - rcpp_result_gen = Rcpp::wrap(io___BufferReader__initialize(buffer)); - return rcpp_result_gen; -END_RCPP -} -// io___Writable__write -void io___Writable__write(const std::shared_ptr& stream, const std::shared_ptr& buf); -RcppExport SEXP _arrow_io___Writable__write(SEXP streamSEXP, SEXP bufSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buf(bufSEXP); - io___Writable__write(stream, buf); - return R_NilValue; -END_RCPP -} -// io___OutputStream__Tell -int64_t io___OutputStream__Tell(const std::shared_ptr& stream); -RcppExport SEXP _arrow_io___OutputStream__Tell(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(io___OutputStream__Tell(stream)); - return rcpp_result_gen; -END_RCPP -} -// io___FileOutputStream__Open -std::shared_ptr io___FileOutputStream__Open(const std::string& path); -RcppExport SEXP _arrow_io___FileOutputStream__Open(SEXP pathSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::string& >::type path(pathSEXP); - rcpp_result_gen = Rcpp::wrap(io___FileOutputStream__Open(path)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferOutputStream__Create -std::shared_ptr io___BufferOutputStream__Create(int64_t initial_capacity); -RcppExport SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacitySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< int64_t >::type initial_capacity(initial_capacitySEXP); - rcpp_result_gen = Rcpp::wrap(io___BufferOutputStream__Create(initial_capacity)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferOutputStream__capacity -int64_t io___BufferOutputStream__capacity(const std::shared_ptr& stream); -RcppExport SEXP _arrow_io___BufferOutputStream__capacity(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(io___BufferOutputStream__capacity(stream)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferOutputStream__Finish -std::shared_ptr io___BufferOutputStream__Finish(const std::shared_ptr& stream); -RcppExport SEXP _arrow_io___BufferOutputStream__Finish(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(io___BufferOutputStream__Finish(stream)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferOutputStream__Tell -int64_t io___BufferOutputStream__Tell(const std::shared_ptr& stream); -RcppExport SEXP _arrow_io___BufferOutputStream__Tell(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(io___BufferOutputStream__Tell(stream)); - return rcpp_result_gen; -END_RCPP -} -// io___BufferOutputStream__Write -void io___BufferOutputStream__Write(const std::shared_ptr& stream, RawVector_ bytes); -RcppExport SEXP _arrow_io___BufferOutputStream__Write(SEXP streamSEXP, SEXP bytesSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - Rcpp::traits::input_parameter< RawVector_ >::type bytes(bytesSEXP); - io___BufferOutputStream__Write(stream, bytes); - return R_NilValue; -END_RCPP -} -// io___MockOutputStream__initialize -std::shared_ptr io___MockOutputStream__initialize(); -RcppExport SEXP _arrow_io___MockOutputStream__initialize() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(io___MockOutputStream__initialize()); - return rcpp_result_gen; -END_RCPP -} -// io___MockOutputStream__GetExtentBytesWritten -int64_t io___MockOutputStream__GetExtentBytesWritten(const std::shared_ptr& stream); -RcppExport SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(io___MockOutputStream__GetExtentBytesWritten(stream)); - return rcpp_result_gen; -END_RCPP -} -// io___FixedSizeBufferWriter__initialize -std::shared_ptr io___FixedSizeBufferWriter__initialize(const std::shared_ptr& buffer); -RcppExport SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP bufferSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type buffer(bufferSEXP); - rcpp_result_gen = Rcpp::wrap(io___FixedSizeBufferWriter__initialize(buffer)); - return rcpp_result_gen; -END_RCPP -} -// MemoryPool__default -std::shared_ptr MemoryPool__default(); -RcppExport SEXP _arrow_MemoryPool__default() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(MemoryPool__default()); - return rcpp_result_gen; -END_RCPP -} -// MemoryPool__bytes_allocated -int MemoryPool__bytes_allocated(const std::shared_ptr& pool); -RcppExport SEXP _arrow_MemoryPool__bytes_allocated(SEXP poolSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type pool(poolSEXP); - rcpp_result_gen = Rcpp::wrap(MemoryPool__bytes_allocated(pool)); - return rcpp_result_gen; -END_RCPP -} -// MemoryPool__max_memory -int MemoryPool__max_memory(const std::shared_ptr& pool); -RcppExport SEXP _arrow_MemoryPool__max_memory(SEXP poolSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type pool(poolSEXP); - rcpp_result_gen = Rcpp::wrap(MemoryPool__max_memory(pool)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__body_length -int64_t ipc___Message__body_length(const std::unique_ptr& message); -RcppExport SEXP _arrow_ipc___Message__body_length(SEXP messageSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__body_length(message)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__metadata -std::shared_ptr ipc___Message__metadata(const std::unique_ptr& message); -RcppExport SEXP _arrow_ipc___Message__metadata(SEXP messageSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__metadata(message)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__body -std::shared_ptr ipc___Message__body(const std::unique_ptr& message); -RcppExport SEXP _arrow_ipc___Message__body(SEXP messageSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__body(message)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__Verify -int64_t ipc___Message__Verify(const std::unique_ptr& message); -RcppExport SEXP _arrow_ipc___Message__Verify(SEXP messageSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__Verify(message)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__type -arrow::ipc::Message::Type ipc___Message__type(const std::unique_ptr& message); -RcppExport SEXP _arrow_ipc___Message__type(SEXP messageSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__type(message)); - return rcpp_result_gen; -END_RCPP -} -// ipc___Message__Equals -bool ipc___Message__Equals(const std::unique_ptr& x, const std::unique_ptr& y); -RcppExport SEXP _arrow_ipc___Message__Equals(SEXP xSEXP, SEXP ySEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type x(xSEXP); - Rcpp::traits::input_parameter< const std::unique_ptr& >::type y(ySEXP); - rcpp_result_gen = Rcpp::wrap(ipc___Message__Equals(x, y)); - return rcpp_result_gen; -END_RCPP -} -// ipc___ReadRecordBatch__Message__Schema -std::shared_ptr ipc___ReadRecordBatch__Message__Schema(const std::unique_ptr& message, const std::shared_ptr& schema); -RcppExport SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP messageSEXP, SEXP schemaSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type message(messageSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___ReadRecordBatch__Message__Schema(message, schema)); - return rcpp_result_gen; -END_RCPP -} -// ipc___ReadSchema_InputStream -std::shared_ptr ipc___ReadSchema_InputStream(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___ReadSchema_InputStream(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___ReadSchema_InputStream(stream)); - return rcpp_result_gen; -END_RCPP -} -// ipc___MessageReader__Open -std::unique_ptr ipc___MessageReader__Open(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___MessageReader__Open(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___MessageReader__Open(stream)); - return rcpp_result_gen; -END_RCPP -} -// ipc___MessageReader__ReadNextMessage -std::unique_ptr ipc___MessageReader__ReadNextMessage(const std::unique_ptr& reader); -RcppExport SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::unique_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___MessageReader__ReadNextMessage(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___ReadMessage -std::unique_ptr ipc___ReadMessage(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___ReadMessage(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___ReadMessage(stream)); - return rcpp_result_gen; -END_RCPP -} -// read_parquet_file -std::shared_ptr read_parquet_file(std::string filename); -RcppExport SEXP _arrow_read_parquet_file(SEXP filenameSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< std::string >::type filename(filenameSEXP); - rcpp_result_gen = Rcpp::wrap(read_parquet_file(filename)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__num_columns -int RecordBatch__num_columns(const std::shared_ptr& x); -RcppExport SEXP _arrow_RecordBatch__num_columns(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__num_columns(x)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__num_rows -int RecordBatch__num_rows(const std::shared_ptr& x); -RcppExport SEXP _arrow_RecordBatch__num_rows(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__num_rows(x)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__schema -std::shared_ptr RecordBatch__schema(const std::shared_ptr& x); -RcppExport SEXP _arrow_RecordBatch__schema(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__schema(x)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__columns -arrow::ArrayVector RecordBatch__columns(const std::shared_ptr& batch); -RcppExport SEXP _arrow_RecordBatch__columns(SEXP batchSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__columns(batch)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__column -std::shared_ptr RecordBatch__column(const std::shared_ptr& batch, int i); -RcppExport SEXP _arrow_RecordBatch__column(SEXP batchSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__column(batch, i)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__Equals -bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other); -RcppExport SEXP _arrow_RecordBatch__Equals(SEXP selfSEXP, SEXP otherSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type self(selfSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type other(otherSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__Equals(self, other)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__RemoveColumn -std::shared_ptr RecordBatch__RemoveColumn(const std::shared_ptr& batch, int i); -RcppExport SEXP _arrow_RecordBatch__RemoveColumn(SEXP batchSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__RemoveColumn(batch, i)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__column_name -std::string RecordBatch__column_name(const std::shared_ptr& batch, int i); -RcppExport SEXP _arrow_RecordBatch__column_name(SEXP batchSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__column_name(batch, i)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__names -Rcpp::CharacterVector RecordBatch__names(const std::shared_ptr& batch); -RcppExport SEXP _arrow_RecordBatch__names(SEXP batchSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__names(batch)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__Slice1 -std::shared_ptr RecordBatch__Slice1(const std::shared_ptr& self, int offset); -RcppExport SEXP _arrow_RecordBatch__Slice1(SEXP selfSEXP, SEXP offsetSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type self(selfSEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__Slice1(self, offset)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__Slice2 -std::shared_ptr RecordBatch__Slice2(const std::shared_ptr& self, int offset, int length); -RcppExport SEXP _arrow_RecordBatch__Slice2(SEXP selfSEXP, SEXP offsetSEXP, SEXP lengthSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type self(selfSEXP); - Rcpp::traits::input_parameter< int >::type offset(offsetSEXP); - Rcpp::traits::input_parameter< int >::type length(lengthSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__Slice2(self, offset, length)); - return rcpp_result_gen; -END_RCPP -} -// ipc___SerializeRecordBatch__Raw -Rcpp::RawVector ipc___SerializeRecordBatch__Raw(const std::shared_ptr& batch); -RcppExport SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batchSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___SerializeRecordBatch__Raw(batch)); - return rcpp_result_gen; -END_RCPP -} -// ipc___ReadRecordBatch__InputStream__Schema -std::shared_ptr ipc___ReadRecordBatch__InputStream__Schema(const std::shared_ptr& stream, const std::shared_ptr& schema); -RcppExport SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP streamSEXP, SEXP schemaSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___ReadRecordBatch__InputStream__Schema(stream, schema)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatch__from_arrays -std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst); -RcppExport SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxpSEXP, SEXP lstSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type schema_sxp(schema_sxpSEXP); - Rcpp::traits::input_parameter< SEXP >::type lst(lstSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatch__from_arrays(schema_sxp, lst)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatchReader__schema -std::shared_ptr RecordBatchReader__schema(const std::shared_ptr& reader); -RcppExport SEXP _arrow_RecordBatchReader__schema(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatchReader__schema(reader)); - return rcpp_result_gen; -END_RCPP -} -// RecordBatchReader__ReadNext -std::shared_ptr RecordBatchReader__ReadNext(const std::shared_ptr& reader); -RcppExport SEXP _arrow_RecordBatchReader__ReadNext(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(RecordBatchReader__ReadNext(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchStreamReader__Open -std::shared_ptr ipc___RecordBatchStreamReader__Open(const std::shared_ptr& stream); -RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP streamSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchStreamReader__Open(stream)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchStreamReader__batches -std::vector> ipc___RecordBatchStreamReader__batches(const std::shared_ptr& reader); -RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchStreamReader__batches(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchFileReader__schema -std::shared_ptr ipc___RecordBatchFileReader__schema(const std::shared_ptr& reader); -RcppExport SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileReader__schema(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchFileReader__num_record_batches -int ipc___RecordBatchFileReader__num_record_batches(const std::shared_ptr& reader); -RcppExport SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileReader__num_record_batches(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchFileReader__ReadRecordBatch -std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch(const std::shared_ptr& reader, int i); -RcppExport SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP readerSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileReader__ReadRecordBatch(reader, i)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchFileReader__Open -std::shared_ptr ipc___RecordBatchFileReader__Open(const std::shared_ptr& file); -RcppExport SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP fileSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type file(fileSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileReader__Open(file)); - return rcpp_result_gen; -END_RCPP -} -// Table__from_RecordBatchFileReader -std::shared_ptr Table__from_RecordBatchFileReader(const std::shared_ptr& reader); -RcppExport SEXP _arrow_Table__from_RecordBatchFileReader(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(Table__from_RecordBatchFileReader(reader)); - return rcpp_result_gen; -END_RCPP -} -// Table__from_RecordBatchStreamReader -std::shared_ptr Table__from_RecordBatchStreamReader(const std::shared_ptr& reader); -RcppExport SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(Table__from_RecordBatchStreamReader(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchFileReader__batches -std::vector> ipc___RecordBatchFileReader__batches(const std::shared_ptr& reader); -RcppExport SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP readerSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type reader(readerSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileReader__batches(reader)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchWriter__WriteRecordBatch -void ipc___RecordBatchWriter__WriteRecordBatch(const std::shared_ptr& batch_writer, const std::shared_ptr& batch); -RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writerSEXP, SEXP batchSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch_writer(batch_writerSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch(batchSEXP); - ipc___RecordBatchWriter__WriteRecordBatch(batch_writer, batch); - return R_NilValue; -END_RCPP -} -// ipc___RecordBatchWriter__WriteTable -void ipc___RecordBatchWriter__WriteTable(const std::shared_ptr& batch_writer, const std::shared_ptr& table); -RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writerSEXP, SEXP tableSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch_writer(batch_writerSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table(tableSEXP); - ipc___RecordBatchWriter__WriteTable(batch_writer, table); - return R_NilValue; -END_RCPP -} -// ipc___RecordBatchWriter__Close -void ipc___RecordBatchWriter__Close(const std::shared_ptr& batch_writer); -RcppExport SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writerSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type batch_writer(batch_writerSEXP); - ipc___RecordBatchWriter__Close(batch_writer); - return R_NilValue; -END_RCPP -} -// ipc___RecordBatchFileWriter__Open -std::shared_ptr ipc___RecordBatchFileWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); -RcppExport SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP streamSEXP, SEXP schemaSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchFileWriter__Open(stream, schema)); - return rcpp_result_gen; -END_RCPP -} -// ipc___RecordBatchStreamWriter__Open -std::shared_ptr ipc___RecordBatchStreamWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); -RcppExport SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP streamSEXP, SEXP schemaSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type stream(streamSEXP); - Rcpp::traits::input_parameter< const std::shared_ptr& >::type schema(schemaSEXP); - rcpp_result_gen = Rcpp::wrap(ipc___RecordBatchStreamWriter__Open(stream, schema)); - return rcpp_result_gen; -END_RCPP -} -// Table__num_columns -int Table__num_columns(const std::shared_ptr& x); -RcppExport SEXP _arrow_Table__num_columns(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Table__num_columns(x)); - return rcpp_result_gen; -END_RCPP -} -// Table__num_rows -int Table__num_rows(const std::shared_ptr& x); -RcppExport SEXP _arrow_Table__num_rows(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Table__num_rows(x)); - return rcpp_result_gen; -END_RCPP -} -// Table__schema -std::shared_ptr Table__schema(const std::shared_ptr& x); -RcppExport SEXP _arrow_Table__schema(SEXP xSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type x(xSEXP); - rcpp_result_gen = Rcpp::wrap(Table__schema(x)); - return rcpp_result_gen; -END_RCPP -} -// Table__column -std::shared_ptr Table__column(const std::shared_ptr& table, int i); -RcppExport SEXP _arrow_Table__column(SEXP tableSEXP, SEXP iSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table(tableSEXP); - Rcpp::traits::input_parameter< int >::type i(iSEXP); - rcpp_result_gen = Rcpp::wrap(Table__column(table, i)); - return rcpp_result_gen; -END_RCPP -} -// Table__columns -std::vector> Table__columns(const std::shared_ptr& table); -RcppExport SEXP _arrow_Table__columns(SEXP tableSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const std::shared_ptr& >::type table(tableSEXP); - rcpp_result_gen = Rcpp::wrap(Table__columns(table)); - return rcpp_result_gen; -END_RCPP -} -// Table__from_dots -std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp); -RcppExport SEXP _arrow_Table__from_dots(SEXP lstSEXP, SEXP schema_sxpSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< SEXP >::type lst(lstSEXP); - Rcpp::traits::input_parameter< SEXP >::type schema_sxp(schema_sxpSEXP); - rcpp_result_gen = Rcpp::wrap(Table__from_dots(lst, schema_sxp)); - return rcpp_result_gen; -END_RCPP -} -// GetCpuThreadPoolCapacity -int GetCpuThreadPoolCapacity(); -RcppExport SEXP _arrow_GetCpuThreadPoolCapacity() { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - rcpp_result_gen = Rcpp::wrap(GetCpuThreadPoolCapacity()); - return rcpp_result_gen; -END_RCPP -} -// SetCpuThreadPoolCapacity -void SetCpuThreadPoolCapacity(int threads); -RcppExport SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threadsSEXP) { -BEGIN_RCPP - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< int >::type threads(threadsSEXP); - SetCpuThreadPoolCapacity(threads); - return R_NilValue; -END_RCPP -} - -static const R_CallMethodDef CallEntries[] = { - {"_arrow_Array__Slice1", (DL_FUNC) &_arrow_Array__Slice1, 2}, - {"_arrow_Array__Slice2", (DL_FUNC) &_arrow_Array__Slice2, 3}, - {"_arrow_Array__IsNull", (DL_FUNC) &_arrow_Array__IsNull, 2}, - {"_arrow_Array__IsValid", (DL_FUNC) &_arrow_Array__IsValid, 2}, - {"_arrow_Array__length", (DL_FUNC) &_arrow_Array__length, 1}, - {"_arrow_Array__offset", (DL_FUNC) &_arrow_Array__offset, 1}, - {"_arrow_Array__null_count", (DL_FUNC) &_arrow_Array__null_count, 1}, - {"_arrow_Array__type", (DL_FUNC) &_arrow_Array__type, 1}, - {"_arrow_Array__ToString", (DL_FUNC) &_arrow_Array__ToString, 1}, - {"_arrow_Array__type_id", (DL_FUNC) &_arrow_Array__type_id, 1}, - {"_arrow_Array__Equals", (DL_FUNC) &_arrow_Array__Equals, 2}, - {"_arrow_Array__ApproxEquals", (DL_FUNC) &_arrow_Array__ApproxEquals, 2}, - {"_arrow_Array__data", (DL_FUNC) &_arrow_Array__data, 1}, - {"_arrow_Array__RangeEquals", (DL_FUNC) &_arrow_Array__RangeEquals, 5}, - {"_arrow_Array__Mask", (DL_FUNC) &_arrow_Array__Mask, 1}, - {"_arrow_DictionaryArray__indices", (DL_FUNC) &_arrow_DictionaryArray__indices, 1}, - {"_arrow_DictionaryArray__dictionary", (DL_FUNC) &_arrow_DictionaryArray__dictionary, 1}, - {"_arrow_Array__as_vector", (DL_FUNC) &_arrow_Array__as_vector, 1}, - {"_arrow_ChunkedArray__as_vector", (DL_FUNC) &_arrow_ChunkedArray__as_vector, 1}, - {"_arrow_RecordBatch__to_dataframe", (DL_FUNC) &_arrow_RecordBatch__to_dataframe, 2}, - {"_arrow_Table__to_dataframe", (DL_FUNC) &_arrow_Table__to_dataframe, 2}, - {"_arrow_Array__infer_type", (DL_FUNC) &_arrow_Array__infer_type, 1}, - {"_arrow_Array__from_vector", (DL_FUNC) &_arrow_Array__from_vector, 2}, - {"_arrow_ChunkedArray__from_list", (DL_FUNC) &_arrow_ChunkedArray__from_list, 2}, - {"_arrow_ArrayData__get_type", (DL_FUNC) &_arrow_ArrayData__get_type, 1}, - {"_arrow_ArrayData__get_length", (DL_FUNC) &_arrow_ArrayData__get_length, 1}, - {"_arrow_ArrayData__get_null_count", (DL_FUNC) &_arrow_ArrayData__get_null_count, 1}, - {"_arrow_ArrayData__get_offset", (DL_FUNC) &_arrow_ArrayData__get_offset, 1}, - {"_arrow_ArrayData__buffers", (DL_FUNC) &_arrow_ArrayData__buffers, 1}, - {"_arrow_Buffer__is_mutable", (DL_FUNC) &_arrow_Buffer__is_mutable, 1}, - {"_arrow_Buffer__ZeroPadding", (DL_FUNC) &_arrow_Buffer__ZeroPadding, 1}, - {"_arrow_Buffer__capacity", (DL_FUNC) &_arrow_Buffer__capacity, 1}, - {"_arrow_Buffer__size", (DL_FUNC) &_arrow_Buffer__size, 1}, - {"_arrow_r___RBuffer__initialize", (DL_FUNC) &_arrow_r___RBuffer__initialize, 1}, - {"_arrow_ChunkedArray__length", (DL_FUNC) &_arrow_ChunkedArray__length, 1}, - {"_arrow_ChunkedArray__null_count", (DL_FUNC) &_arrow_ChunkedArray__null_count, 1}, - {"_arrow_ChunkedArray__num_chunks", (DL_FUNC) &_arrow_ChunkedArray__num_chunks, 1}, - {"_arrow_ChunkedArray__chunk", (DL_FUNC) &_arrow_ChunkedArray__chunk, 2}, - {"_arrow_ChunkedArray__chunks", (DL_FUNC) &_arrow_ChunkedArray__chunks, 1}, - {"_arrow_ChunkedArray__type", (DL_FUNC) &_arrow_ChunkedArray__type, 1}, - {"_arrow_ChunkArray__Slice1", (DL_FUNC) &_arrow_ChunkArray__Slice1, 2}, - {"_arrow_ChunkArray__Slice2", (DL_FUNC) &_arrow_ChunkArray__Slice2, 3}, - {"_arrow_Column__length", (DL_FUNC) &_arrow_Column__length, 1}, - {"_arrow_Column__null_count", (DL_FUNC) &_arrow_Column__null_count, 1}, - {"_arrow_Column__type", (DL_FUNC) &_arrow_Column__type, 1}, - {"_arrow_Column__data", (DL_FUNC) &_arrow_Column__data, 1}, - {"_arrow_util___Codec__Create", (DL_FUNC) &_arrow_util___Codec__Create, 1}, - {"_arrow_io___CompressedOutputStream__Make", (DL_FUNC) &_arrow_io___CompressedOutputStream__Make, 2}, - {"_arrow_io___CompressedInputStream__Make", (DL_FUNC) &_arrow_io___CompressedInputStream__Make, 2}, - {"_arrow_compute___CastOptions__initialize", (DL_FUNC) &_arrow_compute___CastOptions__initialize, 3}, - {"_arrow_Array__cast", (DL_FUNC) &_arrow_Array__cast, 3}, - {"_arrow_ChunkedArray__cast", (DL_FUNC) &_arrow_ChunkedArray__cast, 3}, - {"_arrow_RecordBatch__cast", (DL_FUNC) &_arrow_RecordBatch__cast, 3}, - {"_arrow_Table__cast", (DL_FUNC) &_arrow_Table__cast, 3}, - {"_arrow_csv___ReadOptions__initialize", (DL_FUNC) &_arrow_csv___ReadOptions__initialize, 1}, - {"_arrow_csv___ParseOptions__initialize", (DL_FUNC) &_arrow_csv___ParseOptions__initialize, 1}, - {"_arrow_csv___ConvertOptions__initialize", (DL_FUNC) &_arrow_csv___ConvertOptions__initialize, 1}, - {"_arrow_csv___TableReader__Make", (DL_FUNC) &_arrow_csv___TableReader__Make, 4}, - {"_arrow_csv___TableReader__Read", (DL_FUNC) &_arrow_csv___TableReader__Read, 1}, - {"_arrow_shared_ptr_is_null", (DL_FUNC) &_arrow_shared_ptr_is_null, 1}, - {"_arrow_unique_ptr_is_null", (DL_FUNC) &_arrow_unique_ptr_is_null, 1}, - {"_arrow_Int8__initialize", (DL_FUNC) &_arrow_Int8__initialize, 0}, - {"_arrow_Int16__initialize", (DL_FUNC) &_arrow_Int16__initialize, 0}, - {"_arrow_Int32__initialize", (DL_FUNC) &_arrow_Int32__initialize, 0}, - {"_arrow_Int64__initialize", (DL_FUNC) &_arrow_Int64__initialize, 0}, - {"_arrow_UInt8__initialize", (DL_FUNC) &_arrow_UInt8__initialize, 0}, - {"_arrow_UInt16__initialize", (DL_FUNC) &_arrow_UInt16__initialize, 0}, - {"_arrow_UInt32__initialize", (DL_FUNC) &_arrow_UInt32__initialize, 0}, - {"_arrow_UInt64__initialize", (DL_FUNC) &_arrow_UInt64__initialize, 0}, - {"_arrow_Float16__initialize", (DL_FUNC) &_arrow_Float16__initialize, 0}, - {"_arrow_Float32__initialize", (DL_FUNC) &_arrow_Float32__initialize, 0}, - {"_arrow_Float64__initialize", (DL_FUNC) &_arrow_Float64__initialize, 0}, - {"_arrow_Boolean__initialize", (DL_FUNC) &_arrow_Boolean__initialize, 0}, - {"_arrow_Utf8__initialize", (DL_FUNC) &_arrow_Utf8__initialize, 0}, - {"_arrow_Date32__initialize", (DL_FUNC) &_arrow_Date32__initialize, 0}, - {"_arrow_Date64__initialize", (DL_FUNC) &_arrow_Date64__initialize, 0}, - {"_arrow_Null__initialize", (DL_FUNC) &_arrow_Null__initialize, 0}, - {"_arrow_Decimal128Type__initialize", (DL_FUNC) &_arrow_Decimal128Type__initialize, 2}, - {"_arrow_FixedSizeBinary__initialize", (DL_FUNC) &_arrow_FixedSizeBinary__initialize, 1}, - {"_arrow_Timestamp__initialize1", (DL_FUNC) &_arrow_Timestamp__initialize1, 1}, - {"_arrow_Timestamp__initialize2", (DL_FUNC) &_arrow_Timestamp__initialize2, 2}, - {"_arrow_Time32__initialize", (DL_FUNC) &_arrow_Time32__initialize, 1}, - {"_arrow_Time64__initialize", (DL_FUNC) &_arrow_Time64__initialize, 1}, - {"_arrow_list__", (DL_FUNC) &_arrow_list__, 1}, - {"_arrow_struct_", (DL_FUNC) &_arrow_struct_, 1}, - {"_arrow_DataType__ToString", (DL_FUNC) &_arrow_DataType__ToString, 1}, - {"_arrow_DataType__name", (DL_FUNC) &_arrow_DataType__name, 1}, - {"_arrow_DataType__Equals", (DL_FUNC) &_arrow_DataType__Equals, 2}, - {"_arrow_DataType__num_children", (DL_FUNC) &_arrow_DataType__num_children, 1}, - {"_arrow_DataType__children_pointer", (DL_FUNC) &_arrow_DataType__children_pointer, 1}, - {"_arrow_DataType__id", (DL_FUNC) &_arrow_DataType__id, 1}, - {"_arrow_schema_", (DL_FUNC) &_arrow_schema_, 1}, - {"_arrow_Schema__ToString", (DL_FUNC) &_arrow_Schema__ToString, 1}, - {"_arrow_Schema__num_fields", (DL_FUNC) &_arrow_Schema__num_fields, 1}, - {"_arrow_Schema__field", (DL_FUNC) &_arrow_Schema__field, 2}, - {"_arrow_Schema__names", (DL_FUNC) &_arrow_Schema__names, 1}, - {"_arrow_ListType__ToString", (DL_FUNC) &_arrow_ListType__ToString, 1}, - {"_arrow_FixedWidthType__bit_width", (DL_FUNC) &_arrow_FixedWidthType__bit_width, 1}, - {"_arrow_DateType__unit", (DL_FUNC) &_arrow_DateType__unit, 1}, - {"_arrow_TimeType__unit", (DL_FUNC) &_arrow_TimeType__unit, 1}, - {"_arrow_DecimalType__precision", (DL_FUNC) &_arrow_DecimalType__precision, 1}, - {"_arrow_DecimalType__scale", (DL_FUNC) &_arrow_DecimalType__scale, 1}, - {"_arrow_TimestampType__timezone", (DL_FUNC) &_arrow_TimestampType__timezone, 1}, - {"_arrow_TimestampType__unit", (DL_FUNC) &_arrow_TimestampType__unit, 1}, - {"_arrow_DictionaryType__initialize", (DL_FUNC) &_arrow_DictionaryType__initialize, 3}, - {"_arrow_DictionaryType__index_type", (DL_FUNC) &_arrow_DictionaryType__index_type, 1}, - {"_arrow_DictionaryType__value_type", (DL_FUNC) &_arrow_DictionaryType__value_type, 1}, - {"_arrow_DictionaryType__name", (DL_FUNC) &_arrow_DictionaryType__name, 1}, - {"_arrow_DictionaryType__ordered", (DL_FUNC) &_arrow_DictionaryType__ordered, 1}, - {"_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC) &_arrow_ipc___feather___TableWriter__SetDescription, 2}, - {"_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC) &_arrow_ipc___feather___TableWriter__SetNumRows, 2}, - {"_arrow_ipc___feather___TableWriter__Append", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Append, 3}, - {"_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Finalize, 1}, - {"_arrow_ipc___feather___TableWriter__Open", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Open, 1}, - {"_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC) &_arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2}, - {"_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetDescription, 1}, - {"_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC) &_arrow_ipc___feather___TableReader__HasDescription, 1}, - {"_arrow_ipc___feather___TableReader__version", (DL_FUNC) &_arrow_ipc___feather___TableReader__version, 1}, - {"_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC) &_arrow_ipc___feather___TableReader__num_rows, 1}, - {"_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC) &_arrow_ipc___feather___TableReader__num_columns, 1}, - {"_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetColumnName, 2}, - {"_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetColumn, 2}, - {"_arrow_ipc___feather___TableReader__Read", (DL_FUNC) &_arrow_ipc___feather___TableReader__Read, 2}, - {"_arrow_ipc___feather___TableReader__Open", (DL_FUNC) &_arrow_ipc___feather___TableReader__Open, 1}, - {"_arrow_Field__initialize", (DL_FUNC) &_arrow_Field__initialize, 3}, - {"_arrow_Field__ToString", (DL_FUNC) &_arrow_Field__ToString, 1}, - {"_arrow_Field__name", (DL_FUNC) &_arrow_Field__name, 1}, - {"_arrow_Field__Equals", (DL_FUNC) &_arrow_Field__Equals, 2}, - {"_arrow_Field__nullable", (DL_FUNC) &_arrow_Field__nullable, 1}, - {"_arrow_Field__type", (DL_FUNC) &_arrow_Field__type, 1}, - {"_arrow_io___Readable__Read", (DL_FUNC) &_arrow_io___Readable__Read, 2}, - {"_arrow_io___InputStream__Close", (DL_FUNC) &_arrow_io___InputStream__Close, 1}, - {"_arrow_io___OutputStream__Close", (DL_FUNC) &_arrow_io___OutputStream__Close, 1}, - {"_arrow_io___RandomAccessFile__GetSize", (DL_FUNC) &_arrow_io___RandomAccessFile__GetSize, 1}, - {"_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC) &_arrow_io___RandomAccessFile__supports_zero_copy, 1}, - {"_arrow_io___RandomAccessFile__Seek", (DL_FUNC) &_arrow_io___RandomAccessFile__Seek, 2}, - {"_arrow_io___RandomAccessFile__Tell", (DL_FUNC) &_arrow_io___RandomAccessFile__Tell, 1}, - {"_arrow_io___MemoryMappedFile__Create", (DL_FUNC) &_arrow_io___MemoryMappedFile__Create, 2}, - {"_arrow_io___MemoryMappedFile__Open", (DL_FUNC) &_arrow_io___MemoryMappedFile__Open, 2}, - {"_arrow_io___MemoryMappedFile__Resize", (DL_FUNC) &_arrow_io___MemoryMappedFile__Resize, 2}, - {"_arrow_io___ReadableFile__Open", (DL_FUNC) &_arrow_io___ReadableFile__Open, 1}, - {"_arrow_io___BufferReader__initialize", (DL_FUNC) &_arrow_io___BufferReader__initialize, 1}, - {"_arrow_io___Writable__write", (DL_FUNC) &_arrow_io___Writable__write, 2}, - {"_arrow_io___OutputStream__Tell", (DL_FUNC) &_arrow_io___OutputStream__Tell, 1}, - {"_arrow_io___FileOutputStream__Open", (DL_FUNC) &_arrow_io___FileOutputStream__Open, 1}, - {"_arrow_io___BufferOutputStream__Create", (DL_FUNC) &_arrow_io___BufferOutputStream__Create, 1}, - {"_arrow_io___BufferOutputStream__capacity", (DL_FUNC) &_arrow_io___BufferOutputStream__capacity, 1}, - {"_arrow_io___BufferOutputStream__Finish", (DL_FUNC) &_arrow_io___BufferOutputStream__Finish, 1}, - {"_arrow_io___BufferOutputStream__Tell", (DL_FUNC) &_arrow_io___BufferOutputStream__Tell, 1}, - {"_arrow_io___BufferOutputStream__Write", (DL_FUNC) &_arrow_io___BufferOutputStream__Write, 2}, - {"_arrow_io___MockOutputStream__initialize", (DL_FUNC) &_arrow_io___MockOutputStream__initialize, 0}, - {"_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC) &_arrow_io___MockOutputStream__GetExtentBytesWritten, 1}, - {"_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC) &_arrow_io___FixedSizeBufferWriter__initialize, 1}, - {"_arrow_MemoryPool__default", (DL_FUNC) &_arrow_MemoryPool__default, 0}, - {"_arrow_MemoryPool__bytes_allocated", (DL_FUNC) &_arrow_MemoryPool__bytes_allocated, 1}, - {"_arrow_MemoryPool__max_memory", (DL_FUNC) &_arrow_MemoryPool__max_memory, 1}, - {"_arrow_ipc___Message__body_length", (DL_FUNC) &_arrow_ipc___Message__body_length, 1}, - {"_arrow_ipc___Message__metadata", (DL_FUNC) &_arrow_ipc___Message__metadata, 1}, - {"_arrow_ipc___Message__body", (DL_FUNC) &_arrow_ipc___Message__body, 1}, - {"_arrow_ipc___Message__Verify", (DL_FUNC) &_arrow_ipc___Message__Verify, 1}, - {"_arrow_ipc___Message__type", (DL_FUNC) &_arrow_ipc___Message__type, 1}, - {"_arrow_ipc___Message__Equals", (DL_FUNC) &_arrow_ipc___Message__Equals, 2}, - {"_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC) &_arrow_ipc___ReadRecordBatch__Message__Schema, 2}, - {"_arrow_ipc___ReadSchema_InputStream", (DL_FUNC) &_arrow_ipc___ReadSchema_InputStream, 1}, - {"_arrow_ipc___MessageReader__Open", (DL_FUNC) &_arrow_ipc___MessageReader__Open, 1}, - {"_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC) &_arrow_ipc___MessageReader__ReadNextMessage, 1}, - {"_arrow_ipc___ReadMessage", (DL_FUNC) &_arrow_ipc___ReadMessage, 1}, - {"_arrow_read_parquet_file", (DL_FUNC) &_arrow_read_parquet_file, 1}, - {"_arrow_RecordBatch__num_columns", (DL_FUNC) &_arrow_RecordBatch__num_columns, 1}, - {"_arrow_RecordBatch__num_rows", (DL_FUNC) &_arrow_RecordBatch__num_rows, 1}, - {"_arrow_RecordBatch__schema", (DL_FUNC) &_arrow_RecordBatch__schema, 1}, - {"_arrow_RecordBatch__columns", (DL_FUNC) &_arrow_RecordBatch__columns, 1}, - {"_arrow_RecordBatch__column", (DL_FUNC) &_arrow_RecordBatch__column, 2}, - {"_arrow_RecordBatch__Equals", (DL_FUNC) &_arrow_RecordBatch__Equals, 2}, - {"_arrow_RecordBatch__RemoveColumn", (DL_FUNC) &_arrow_RecordBatch__RemoveColumn, 2}, - {"_arrow_RecordBatch__column_name", (DL_FUNC) &_arrow_RecordBatch__column_name, 2}, - {"_arrow_RecordBatch__names", (DL_FUNC) &_arrow_RecordBatch__names, 1}, - {"_arrow_RecordBatch__Slice1", (DL_FUNC) &_arrow_RecordBatch__Slice1, 2}, - {"_arrow_RecordBatch__Slice2", (DL_FUNC) &_arrow_RecordBatch__Slice2, 3}, - {"_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC) &_arrow_ipc___SerializeRecordBatch__Raw, 1}, - {"_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC) &_arrow_ipc___ReadRecordBatch__InputStream__Schema, 2}, - {"_arrow_RecordBatch__from_arrays", (DL_FUNC) &_arrow_RecordBatch__from_arrays, 2}, - {"_arrow_RecordBatchReader__schema", (DL_FUNC) &_arrow_RecordBatchReader__schema, 1}, - {"_arrow_RecordBatchReader__ReadNext", (DL_FUNC) &_arrow_RecordBatchReader__ReadNext, 1}, - {"_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC) &_arrow_ipc___RecordBatchStreamReader__Open, 1}, - {"_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC) &_arrow_ipc___RecordBatchStreamReader__batches, 1}, - {"_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__schema, 1}, - {"_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__num_record_batches, 1}, - {"_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2}, - {"_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__Open, 1}, - {"_arrow_Table__from_RecordBatchFileReader", (DL_FUNC) &_arrow_Table__from_RecordBatchFileReader, 1}, - {"_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC) &_arrow_Table__from_RecordBatchStreamReader, 1}, - {"_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__batches, 1}, - {"_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2}, - {"_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__WriteTable, 2}, - {"_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__Close, 1}, - {"_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC) &_arrow_ipc___RecordBatchFileWriter__Open, 2}, - {"_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC) &_arrow_ipc___RecordBatchStreamWriter__Open, 2}, - {"_arrow_Table__num_columns", (DL_FUNC) &_arrow_Table__num_columns, 1}, - {"_arrow_Table__num_rows", (DL_FUNC) &_arrow_Table__num_rows, 1}, - {"_arrow_Table__schema", (DL_FUNC) &_arrow_Table__schema, 1}, - {"_arrow_Table__column", (DL_FUNC) &_arrow_Table__column, 2}, - {"_arrow_Table__columns", (DL_FUNC) &_arrow_Table__columns, 1}, - {"_arrow_Table__from_dots", (DL_FUNC) &_arrow_Table__from_dots, 2}, - {"_arrow_GetCpuThreadPoolCapacity", (DL_FUNC) &_arrow_GetCpuThreadPoolCapacity, 0}, - {"_arrow_SetCpuThreadPoolCapacity", (DL_FUNC) &_arrow_SetCpuThreadPoolCapacity, 1}, - {NULL, NULL, 0} -}; - -RcppExport void R_init_arrow(DllInfo *dll) { - R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); - R_useDynamicSymbols(dll, FALSE); -} diff --git a/r/src/Rcpp_arrow_definitions.h b/r/src/Rcpp_arrow_definitions.h new file mode 100644 index 00000000000..0be44024a38 --- /dev/null +++ b/r/src/Rcpp_arrow_definitions.h @@ -0,0 +1,66 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +namespace Rcpp { +namespace internal { + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag) { + return Rcpp::XPtr>( + new std::shared_ptr(x)); +} + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag) { + return Rcpp::XPtr>( + new std::unique_ptr(const_cast(x).release())); +} + +} // namespace internal + +} // namespace Rcpp + +namespace Rcpp { +using NumericVector_ = Rcpp::Vector; +using IntegerVector_ = Rcpp::Vector; +using LogicalVector_ = Rcpp::Vector; +using StringVector_ = Rcpp::Vector; +using CharacterVector_ = StringVector_; +using RawVector_ = Rcpp::Vector; +using List_ = Rcpp::Vector; + +template +inline constexpr typename Rcpp::Vector::stored_type default_value() { + return Rcpp::Vector::get_na(); +} +template <> +inline constexpr Rbyte default_value() { + return 0; +} + +} // namespace Rcpp + +namespace arrow { +namespace r { + +template +inline std::shared_ptr extract(SEXP x) { + return Rcpp::ConstReferenceSmartPtrInputParameter>(x); +} + +} // namespace r +} // namespace arrow diff --git a/r/src/Rcpp_arrow_forward.h b/r/src/Rcpp_arrow_forward.h new file mode 100644 index 00000000000..295eccc280f --- /dev/null +++ b/r/src/Rcpp_arrow_forward.h @@ -0,0 +1,98 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "./symbols.h" + +#define STOP_IF_NOT(TEST, MSG) \ +do { \ + if (!(TEST)) Rcpp::stop(MSG); \ +} while (0) + +#define STOP_IF_NOT_OK(s) STOP_IF_NOT(s.ok(), s.ToString()) + +template +inline void STOP_IF_NULL(T* ptr) { + STOP_IF_NOT(ptr, "invalid data"); +} + +template +struct NoDelete { + inline void operator()(T* ptr) {} +}; + +namespace Rcpp { +namespace internal { + +template +Pointer r6_to_smart_pointer(SEXP self) { + return reinterpret_cast( + EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); +} + +} // namespace internal + +template +class ConstReferenceSmartPtrInputParameter { +public: + using const_reference = const T&; + + explicit ConstReferenceSmartPtrInputParameter(SEXP self) + : ptr(internal::r6_to_smart_pointer(self)) {} + + inline operator const_reference() { return *ptr; } + +private: + const T* ptr; +}; + +namespace traits { + +template +struct input_parameter&> { + typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; +}; + +template +struct input_parameter&> { + typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; +}; + +struct wrap_type_shared_ptr_tag {}; +struct wrap_type_unique_ptr_tag {}; + +template +struct wrap_type_traits> { + using wrap_category = wrap_type_shared_ptr_tag; +}; + +template +struct wrap_type_traits> { + using wrap_category = wrap_type_unique_ptr_tag; +}; + +} // namespace traits + +namespace internal { + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag); + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag); + +} // namespace internal +} // namespace Rcpp diff --git a/r/src/array.cpp b/r/src/array.cpp index e4ad68d4b58..60fd7da8b9a 100644 --- a/r/src/array.cpp +++ b/r/src/array.cpp @@ -20,76 +20,78 @@ using Rcpp::LogicalVector; using Rcpp::no_init; -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr Array__Slice1(const std::shared_ptr& array, int offset) { return array->Slice(offset); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__Slice2(const std::shared_ptr& array, int offset, int length) { return array->Slice(offset, length); } -// [[Rcpp::export]] +// [[arrow::export]] bool Array__IsNull(const std::shared_ptr& x, int i) { return x->IsNull(i); } -// [[Rcpp::export]] +// [[arrow::export]] bool Array__IsValid(const std::shared_ptr& x, int i) { return x->IsValid(i); } -// [[Rcpp::export]] +// [[arrow::export]] int Array__length(const std::shared_ptr& x) { return x->length(); } -// [[Rcpp::export]] +// [[arrow::export]] int Array__offset(const std::shared_ptr& x) { return x->offset(); } -// [[Rcpp::export]] +// [[arrow::export]] int Array__null_count(const std::shared_ptr& x) { return x->null_count(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__type(const std::shared_ptr& x) { return x->type(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string Array__ToString(const std::shared_ptr& x) { return x->ToString(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::Type::type Array__type_id(const std::shared_ptr& x) { return x->type_id(); } -// [[Rcpp::export]] +// [[arrow::export]] bool Array__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs) { return lhs->Equals(rhs); } -// [[Rcpp::export]] +// [[arrow::export]] bool Array__ApproxEquals(const std::shared_ptr& lhs, const std::shared_ptr& rhs) { return lhs->ApproxEquals(rhs); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__data( const std::shared_ptr& array) { return array->data(); } -// [[Rcpp::export]] +// [[arrow::export]] bool Array__RangeEquals(const std::shared_ptr& self, const std::shared_ptr& other, int start_idx, int end_idx, int other_start_idx) { return self->RangeEquals(*other, start_idx, end_idx, other_start_idx); } -// [[Rcpp::export]] +// [[arrow::export]] LogicalVector Array__Mask(const std::shared_ptr& array) { if (array->null_count() == 0) { return LogicalVector(array->length(), true); @@ -105,14 +107,16 @@ LogicalVector Array__Mask(const std::shared_ptr& array) { return res; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr DictionaryArray__indices( const std::shared_ptr& array) { return array->indices(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr DictionaryArray__dictionary( const std::shared_ptr& array) { return array->dictionary(); } + +#endif diff --git a/r/src/array__to_vector.cpp b/r/src/array__to_vector.cpp index 219b19d1a50..65670e8a50e 100644 --- a/r/src/array__to_vector.cpp +++ b/r/src/array__to_vector.cpp @@ -15,9 +15,11 @@ // specific language governing permissions and limitations // under the License. +#include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) + #include #include -#include "./arrow_types.h" namespace arrow { namespace r { @@ -664,18 +666,18 @@ Rcpp::List to_dataframe_parallel( } // namespace r } // namespace arrow -// [[Rcpp::export]] +// [[arrow::export]] SEXP Array__as_vector(const std::shared_ptr& array) { return arrow::r::ArrayVector__as_vector(array->length(), {array}); } -// [[Rcpp::export]] +// [[arrow::export]] SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array) { return arrow::r::ArrayVector__as_vector(chunked_array->length(), chunked_array->chunks()); } -// [[Rcpp::export]] +// [[arrow::export]] Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& batch, bool use_threads) { int64_t nc = batch->num_columns(); @@ -697,7 +699,7 @@ Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& } } -// [[Rcpp::export]] +// [[arrow::export]] Rcpp::List Table__to_dataframe(const std::shared_ptr& table, bool use_threads) { int64_t nc = table->num_columns(); @@ -716,3 +718,5 @@ Rcpp::List Table__to_dataframe(const std::shared_ptr& table, return arrow::r::to_dataframe_serial(nr, nc, names, converters); } } + +#endif diff --git a/r/src/array_from_vector.cpp b/r/src/array_from_vector.cpp index e2b82ac90f1..98e59ff6af6 100644 --- a/r/src/array_from_vector.cpp +++ b/r/src/array_from_vector.cpp @@ -16,6 +16,7 @@ // under the License. #include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) namespace arrow { namespace r { @@ -955,12 +956,12 @@ std::shared_ptr Array__from_vector( } // namespace r } // namespace arrow -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__infer_type(SEXP x) { return arrow::r::InferType(x); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__from_vector(SEXP x, SEXP s_type) { // the type might be NULL, in which case we need to infer it from the data // we keep track of whether it was infered or supplied @@ -975,7 +976,7 @@ std::shared_ptr Array__from_vector(SEXP x, SEXP s_type) { return arrow::r::Array__from_vector(x, type, type_infered); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, SEXP s_type) { std::vector> vec; @@ -1016,3 +1017,5 @@ std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, return std::make_shared(std::move(vec)); } + +#endif diff --git a/r/src/arraydata.cpp b/r/src/arraydata.cpp index 52367c517d4..f82d305a886 100644 --- a/r/src/arraydata.cpp +++ b/r/src/arraydata.cpp @@ -20,28 +20,32 @@ using Rcpp::List; using Rcpp::wrap; -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr ArrayData__get_type( const std::shared_ptr& x) { return x->type; } -// [[Rcpp::export]] +// [[arrow::export]] int ArrayData__get_length(const std::shared_ptr& x) { return x->length; } -// [[Rcpp::export]] +// [[arrow::export]] int ArrayData__get_null_count(const std::shared_ptr& x) { return x->null_count; } -// [[Rcpp::export]] +// [[arrow::export]] int ArrayData__get_offset(const std::shared_ptr& x) { return x->offset; } -// [[Rcpp::export]] +// [[arrow::export]] List ArrayData__buffers(const std::shared_ptr& x) { return wrap(x->buffers); } + +#endif diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h index 9c5cc28a73c..51ffdef4b8b 100644 --- a/r/src/arrow_types.h +++ b/r/src/arrow_types.h @@ -22,10 +22,14 @@ #include #include -#include "./symbols.h" - #undef Free +#include "./symbols.h" +#include "./Rcpp_arrow_forward.h" +#include +#include "./Rcpp_arrow_definitions.h" + +#if defined(ARROW_R_WITH_ARROW) #include #include #include @@ -38,89 +42,6 @@ #include #include -#define STOP_IF(TEST, MSG) \ - do { \ - if (TEST) Rcpp::stop(MSG); \ - } while (0) - -#define STOP_IF_NOT(TEST, MSG) STOP_IF(!(TEST), MSG) -#define STOP_IF_NOT_OK(s) STOP_IF_NOT(s.ok(), s.ToString()) - -template -inline void STOP_IF_NULL(T* ptr) { - STOP_IF_NOT(ptr, "invalid data"); -} - -template -struct NoDelete { - inline void operator()(T* ptr) {} -}; - -namespace Rcpp { -namespace internal { - -template -Pointer r6_to_smart_pointer(SEXP self) { - return reinterpret_cast( - EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); -} - -} // namespace internal - -template -class ConstReferenceSmartPtrInputParameter { - public: - using const_reference = const T&; - - explicit ConstReferenceSmartPtrInputParameter(SEXP self) - : ptr(internal::r6_to_smart_pointer(self)) {} - - inline operator const_reference() { return *ptr; } - - private: - const T* ptr; -}; - -namespace traits { - -template -struct input_parameter&> { - typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; -}; - -template -struct input_parameter&> { - typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; -}; - -struct wrap_type_shared_ptr_tag {}; -struct wrap_type_unique_ptr_tag {}; - -template -struct wrap_type_traits> { - using wrap_category = wrap_type_shared_ptr_tag; -}; - -template -struct wrap_type_traits> { - using wrap_category = wrap_type_unique_ptr_tag; -}; - -} // namespace traits -namespace internal { - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag); - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag); - -} // namespace internal - -} // namespace Rcpp - -#include - RCPP_EXPOSED_ENUM_NODECL(arrow::Type::type) RCPP_EXPOSED_ENUM_NODECL(arrow::DateUnit) RCPP_EXPOSED_ENUM_NODECL(arrow::TimeUnit::type) @@ -129,45 +50,6 @@ RCPP_EXPOSED_ENUM_NODECL(arrow::io::FileMode::type) RCPP_EXPOSED_ENUM_NODECL(arrow::ipc::Message::Type) RCPP_EXPOSED_ENUM_NODECL(arrow::Compression::type) -namespace Rcpp { -namespace internal { - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag) { - return Rcpp::XPtr>( - new std::shared_ptr(x)); -} - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag) { - return Rcpp::XPtr>( - new std::unique_ptr(const_cast(x).release())); -} - -} // namespace internal - -} // namespace Rcpp - -namespace Rcpp { -using NumericVector_ = Rcpp::Vector; -using IntegerVector_ = Rcpp::Vector; -using LogicalVector_ = Rcpp::Vector; -using StringVector_ = Rcpp::Vector; -using CharacterVector_ = StringVector_; -using RawVector_ = Rcpp::Vector; -using List_ = Rcpp::Vector; - -template -inline constexpr typename Rcpp::Vector::stored_type default_value() { - return Rcpp::Vector::get_na(); -} -template <> -inline constexpr Rbyte default_value() { - return 0; -} - -} // namespace Rcpp - SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array); SEXP Array__as_vector(const std::shared_ptr& array); std::shared_ptr Array__from_vector(SEXP x, SEXP type); @@ -183,34 +65,18 @@ constexpr int64_t NA_INT64 = std::numeric_limits::min(); template > class RBuffer : public MutableBuffer { - public: +public: explicit RBuffer(Vec vec) - : MutableBuffer(reinterpret_cast(vec.begin()), - vec.size() * sizeof(typename Vec::stored_type)), - vec_(vec) {} + : MutableBuffer(reinterpret_cast(vec.begin()), + vec.size() * sizeof(typename Vec::stored_type)), + vec_(vec) {} - private: +private: // vec_ holds the memory Vec vec_; }; -template -inline std::shared_ptr extract(SEXP x) { - return Rcpp::ConstReferenceSmartPtrInputParameter>(x); } - -template -std::vector> list_to_shared_ptr_vector(SEXP lst) { - R_xlen_t n = XLENGTH(lst); - std::vector> res(n); - for (R_xlen_t i = 0; i < n; i++) { - res[i] = extract(VECTOR_ELT(lst, i)); - } - return res; } -std::shared_ptr Array__from_vector( - SEXP x, const std::shared_ptr& type, bool type_infered); - -} // namespace r -} // namespace arrow +#endif diff --git a/r/src/buffer.cpp b/r/src/buffer.cpp index bc52e693e42..afc0d49be20 100644 --- a/r/src/buffer.cpp +++ b/r/src/buffer.cpp @@ -17,27 +17,29 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] bool Buffer__is_mutable(const std::shared_ptr& buffer) { return buffer->is_mutable(); } -// [[Rcpp::export]] +// [[arrow::export]] void Buffer__ZeroPadding(const std::shared_ptr& buffer) { buffer->ZeroPadding(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t Buffer__capacity(const std::shared_ptr& buffer) { return buffer->capacity(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t Buffer__size(const std::shared_ptr& buffer) { return buffer->size(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr r___RBuffer__initialize(SEXP x) { switch (TYPEOF(x)) { case RAWSXP: @@ -54,3 +56,5 @@ std::shared_ptr r___RBuffer__initialize(SEXP x) { } return nullptr; } + +#endif diff --git a/r/src/chunkedarray.cpp b/r/src/chunkedarray.cpp index dab1f684878..296f514adf1 100644 --- a/r/src/chunkedarray.cpp +++ b/r/src/chunkedarray.cpp @@ -20,46 +20,50 @@ using Rcpp::List; using Rcpp::wrap; -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] int ChunkedArray__length(const std::shared_ptr& chunked_array) { return chunked_array->length(); } -// [[Rcpp::export]] +// [[arrow::export]] int ChunkedArray__null_count(const std::shared_ptr& chunked_array) { return chunked_array->null_count(); } -// [[Rcpp::export]] +// [[arrow::export]] int ChunkedArray__num_chunks(const std::shared_ptr& chunked_array) { return chunked_array->num_chunks(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkedArray__chunk( const std::shared_ptr& chunked_array, int i) { return chunked_array->chunk(i); } -// [[Rcpp::export]] +// [[arrow::export]] List ChunkedArray__chunks(const std::shared_ptr& chunked_array) { return wrap(chunked_array->chunks()); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkedArray__type( const std::shared_ptr& chunked_array) { return chunked_array->type(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkArray__Slice1( const std::shared_ptr& chunked_array, int offset) { return chunked_array->Slice(offset); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkArray__Slice2( const std::shared_ptr& chunked_array, int offset, int length) { return chunked_array->Slice(offset, length); } + +#endif diff --git a/r/src/column.cpp b/r/src/column.cpp index b6eff6b7c17..026cb6904d4 100644 --- a/r/src/column.cpp +++ b/r/src/column.cpp @@ -17,24 +17,28 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] int Column__length(const std::shared_ptr& column) { return column->length(); } -// [[Rcpp::export]] +// [[arrow::export]] int Column__null_count(const std::shared_ptr& column) { return column->null_count(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Column__type( const std::shared_ptr& column) { return column->type(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Column__data( const std::shared_ptr& column) { return column->data(); } + +#endif diff --git a/r/src/compression.cpp b/r/src/compression.cpp index c9dadc36840..0a4a6d3aede 100644 --- a/r/src/compression.cpp +++ b/r/src/compression.cpp @@ -17,14 +17,16 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::unique_ptr util___Codec__Create(arrow::Compression::type codec) { std::unique_ptr out; STOP_IF_NOT_OK(arrow::util::Codec::Create(codec, &out)); return out; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___CompressedOutputStream__Make( const std::unique_ptr& codec, const std::shared_ptr& raw) { @@ -33,7 +35,7 @@ std::shared_ptr io___CompressedOutputStream__ return stream; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___CompressedInputStream__Make( const std::unique_ptr& codec, const std::shared_ptr& raw) { @@ -41,3 +43,5 @@ std::shared_ptr io___CompressedInputStream__Ma STOP_IF_NOT_OK(arrow::io::CompressedInputStream::Make(codec.get(), raw, &stream)); return stream; } + +#endif diff --git a/r/src/compute.cpp b/r/src/compute.cpp index 42b73ce9596..4e4091017c1 100644 --- a/r/src/compute.cpp +++ b/r/src/compute.cpp @@ -17,7 +17,9 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr compute___CastOptions__initialize( bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate) { auto options = std::make_shared(); @@ -27,7 +29,7 @@ std::shared_ptr compute___CastOptions__initialize( return options; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Array__cast( const std::shared_ptr& array, const std::shared_ptr& target_type, @@ -38,7 +40,7 @@ std::shared_ptr Array__cast( return out; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ChunkedArray__cast( const std::shared_ptr& chunked_array, const std::shared_ptr& target_type, @@ -50,7 +52,7 @@ std::shared_ptr ChunkedArray__cast( return out.chunked_array(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__cast( const std::shared_ptr& batch, const std::shared_ptr& schema, @@ -65,7 +67,7 @@ std::shared_ptr RecordBatch__cast( return arrow::RecordBatch::Make(schema, batch->num_rows(), std::move(columns)); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__cast( const std::shared_ptr& table, const std::shared_ptr& schema, @@ -82,3 +84,5 @@ std::shared_ptr Table__cast( return arrow::Table::Make(schema, std::move(columns), table->num_rows()); } + +#endif diff --git a/r/src/csv.cpp b/r/src/csv.cpp index 09580beddf7..bfcbae7a7cf 100644 --- a/r/src/csv.cpp +++ b/r/src/csv.cpp @@ -20,7 +20,9 @@ using Rcpp::CharacterVector; using Rcpp::List_; -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr csv___ReadOptions__initialize(List_ options) { auto res = std::make_shared(arrow::csv::ReadOptions::Defaults()); @@ -31,7 +33,7 @@ std::shared_ptr csv___ReadOptions__initialize(List_ opt inline char get_char(CharacterVector x) { return CHAR(STRING_ELT(x, 0))[0]; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr csv___ParseOptions__initialize(List_ options) { auto res = std::make_shared(arrow::csv::ParseOptions::Defaults()); @@ -46,7 +48,7 @@ std::shared_ptr csv___ParseOptions__initialize(List_ o return res; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr csv___ConvertOptions__initialize( List_ options) { auto res = std::make_shared( @@ -55,7 +57,7 @@ std::shared_ptr csv___ConvertOptions__initialize( return res; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr csv___TableReader__Make( const std::shared_ptr& input, const std::shared_ptr& read_options, @@ -68,10 +70,12 @@ std::shared_ptr csv___TableReader__Make( return table_reader; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr csv___TableReader__Read( const std::shared_ptr& table_reader) { std::shared_ptr table; STOP_IF_NOT_OK(table_reader->Read(&table)); return table; } + +#endif diff --git a/r/src/datatype.cpp b/r/src/datatype.cpp index b0becb458b7..1447553a25b 100644 --- a/r/src/datatype.cpp +++ b/r/src/datatype.cpp @@ -22,97 +22,99 @@ using Rcpp::List; using Rcpp::stop; using Rcpp::wrap; -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] bool shared_ptr_is_null(SEXP xp) { return reinterpret_cast*>(EXTPTR_PTR(xp))->get() == nullptr; } -// [[Rcpp::export]] +// [[arrow::export]] bool unique_ptr_is_null(SEXP xp) { return reinterpret_cast*>(EXTPTR_PTR(xp))->get() == nullptr; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Int8__initialize() { return arrow::int8(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Int16__initialize() { return arrow::int16(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Int32__initialize() { return arrow::int32(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Int64__initialize() { return arrow::int64(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr UInt8__initialize() { return arrow::uint8(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr UInt16__initialize() { return arrow::uint16(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr UInt32__initialize() { return arrow::uint32(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr UInt64__initialize() { return arrow::uint64(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Float16__initialize() { return arrow::float16(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Float32__initialize() { return arrow::float32(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Float64__initialize() { return arrow::float64(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Boolean__initialize() { return arrow::boolean(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Utf8__initialize() { return arrow::utf8(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Date32__initialize() { return arrow::date32(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Date64__initialize() { return arrow::date64(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Null__initialize() { return arrow::null(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Decimal128Type__initialize(int32_t precision, int32_t scale) { return arrow::decimal(precision, scale); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr FixedSizeBinary__initialize(int32_t byte_width) { return arrow::fixed_size_binary(byte_width); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Timestamp__initialize1(arrow::TimeUnit::type unit) { return arrow::timestamp(unit); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Timestamp__initialize2(arrow::TimeUnit::type unit, const std::string& timezone) { return arrow::timestamp(unit, timezone); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Time32__initialize(arrow::TimeUnit::type unit) { return arrow::time32(unit); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Time64__initialize(arrow::TimeUnit::type unit) { return arrow::time64(unit); } -// [[Rcpp::export]] +// [[arrow::export]] SEXP list__(SEXP x) { if (Rf_inherits(x, "arrow::Field")) { Rcpp::ConstReferenceSmartPtrInputParameter> field(x); @@ -138,58 +140,58 @@ std::vector> List_to_shared_ptr_vector(List x) { return vec; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr struct_(List fields) { return arrow::struct_(List_to_shared_ptr_vector(fields)); } -// [[Rcpp::export]] +// [[arrow::export]] std::string DataType__ToString(const std::shared_ptr& type) { return type->ToString(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string DataType__name(const std::shared_ptr& type) { return type->name(); } -// [[Rcpp::export]] +// [[arrow::export]] bool DataType__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs) { return lhs->Equals(*rhs); } -// [[Rcpp::export]] +// [[arrow::export]] int DataType__num_children(const std::shared_ptr& type) { return type->num_children(); } -// [[Rcpp::export]] +// [[arrow::export]] List DataType__children_pointer(const std::shared_ptr& type) { return List(type->children().begin(), type->children().end()); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::Type::type DataType__id(const std::shared_ptr& type) { return type->id(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr schema_(List fields) { return arrow::schema(List_to_shared_ptr_vector(fields)); } -// [[Rcpp::export]] +// [[arrow::export]] std::string Schema__ToString(const std::shared_ptr& s) { return s->ToString(); } -// [[Rcpp::export]] +// [[arrow::export]] int Schema__num_fields(const std::shared_ptr& s) { return s->num_fields(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Schema__field(const std::shared_ptr& s, int i) { if (i >= s->num_fields() || i < 0) { @@ -199,7 +201,7 @@ std::shared_ptr Schema__field(const std::shared_ptr return s->field(i); } -// [[Rcpp::export]] +// [[arrow::export]] CharacterVector Schema__names(const std::shared_ptr& schema) { auto fields = schema->fields(); return CharacterVector( @@ -207,72 +209,74 @@ CharacterVector Schema__names(const std::shared_ptr& schema) { [](const std::shared_ptr& field) { return field->name(); }); } -// [[Rcpp::export]] +// [[arrow::export]] std::string ListType__ToString(const std::shared_ptr& type) { return type->ToString(); } -// [[Rcpp::export]] +// [[arrow::export]] int FixedWidthType__bit_width(const std::shared_ptr& type) { return type->bit_width(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::DateUnit DateType__unit(const std::shared_ptr& type) { return type->unit(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::TimeUnit::type TimeType__unit(const std::shared_ptr& type) { return type->unit(); } -// [[Rcpp::export]] +// [[arrow::export]] int32_t DecimalType__precision(const std::shared_ptr& type) { return type->precision(); } -// [[Rcpp::export]] +// [[arrow::export]] int32_t DecimalType__scale(const std::shared_ptr& type) { return type->scale(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string TimestampType__timezone(const std::shared_ptr& type) { return type->timezone(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::TimeUnit::type TimestampType__unit( const std::shared_ptr& type) { return type->unit(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr DictionaryType__initialize( const std::shared_ptr& index_type, const std::shared_ptr& value_type, bool ordered) { return arrow::dictionary(index_type, value_type, ordered); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr DictionaryType__index_type( const std::shared_ptr& type) { return type->index_type(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr DictionaryType__value_type( const std::shared_ptr& type) { return type->value_type(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string DictionaryType__name(const std::shared_ptr& type) { return type->name(); } -// [[Rcpp::export]] +// [[arrow::export]] bool DictionaryType__ordered(const std::shared_ptr& type) { return type->ordered(); } + +#endif diff --git a/r/src/feather.cpp b/r/src/feather.cpp index d981b4d490e..2836ba86bc8 100644 --- a/r/src/feather.cpp +++ b/r/src/feather.cpp @@ -17,35 +17,37 @@ #include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) + // ---------- TableWriter -// [[Rcpp::export]] +// [[arrow::export]] void ipc___feather___TableWriter__SetDescription( const std::unique_ptr& writer, const std::string& description) { writer->SetDescription(description); } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___feather___TableWriter__SetNumRows( const std::unique_ptr& writer, int64_t num_rows) { writer->SetNumRows(num_rows); } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___feather___TableWriter__Append( const std::unique_ptr& writer, const std::string& name, const std::shared_ptr& values) { STOP_IF_NOT_OK(writer->Append(name, *values)); } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___feather___TableWriter__Finalize( const std::unique_ptr& writer) { STOP_IF_NOT_OK(writer->Finalize()); } -// [[Rcpp::export]] +// [[arrow::export]] std::unique_ptr ipc___feather___TableWriter__Open( const std::shared_ptr& stream) { std::unique_ptr writer; @@ -53,7 +55,7 @@ std::unique_ptr ipc___feather___TableWriter__O return writer; } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___TableWriter__RecordBatch__WriteFeather( const std::unique_ptr& writer, const std::shared_ptr& batch) { @@ -67,43 +69,43 @@ void ipc___TableWriter__RecordBatch__WriteFeather( // ----------- TableReader -// [[Rcpp::export]] +// [[arrow::export]] std::string ipc___feather___TableReader__GetDescription( const std::unique_ptr& reader) { return reader->GetDescription(); } -// [[Rcpp::export]] +// [[arrow::export]] bool ipc___feather___TableReader__HasDescription( const std::unique_ptr& reader) { return reader->HasDescription(); } -// [[Rcpp::export]] +// [[arrow::export]] int ipc___feather___TableReader__version( const std::unique_ptr& reader) { return reader->version(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t ipc___feather___TableReader__num_rows( const std::unique_ptr& reader) { return reader->num_rows(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t ipc___feather___TableReader__num_columns( const std::unique_ptr& reader) { return reader->num_columns(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string ipc___feather___TableReader__GetColumnName( const std::unique_ptr& reader, int i) { return reader->GetColumnName(i); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___feather___TableReader__GetColumn( const std::unique_ptr& reader, int i) { std::shared_ptr column; @@ -111,7 +113,7 @@ std::shared_ptr ipc___feather___TableReader__GetColumn( return column; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___feather___TableReader__Read( const std::unique_ptr& reader, SEXP columns) { std::shared_ptr table; @@ -147,10 +149,12 @@ std::shared_ptr ipc___feather___TableReader__Read( return table; } -// [[Rcpp::export]] +// [[arrow::export]] std::unique_ptr ipc___feather___TableReader__Open( const std::shared_ptr& stream) { std::unique_ptr reader; STOP_IF_NOT_OK(arrow::ipc::feather::TableReader::Open(stream, &reader)); return reader; } + +#endif diff --git a/r/src/field.cpp b/r/src/field.cpp index e864bac5596..249393f1495 100644 --- a/r/src/field.cpp +++ b/r/src/field.cpp @@ -17,35 +17,39 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr Field__initialize( const std::string& name, const std::shared_ptr& field, bool nullable = true) { return arrow::field(name, field, nullable); } -// [[Rcpp::export]] +// [[arrow::export]] std::string Field__ToString(const std::shared_ptr& field) { return field->ToString(); } -// [[Rcpp::export]] +// [[arrow::export]] std::string Field__name(const std::shared_ptr& field) { return field->name(); } -// [[Rcpp::export]] +// [[arrow::export]] bool Field__Equals(const std::shared_ptr& field, const std::shared_ptr& other) { return field->Equals(other); } -// [[Rcpp::export]] +// [[arrow::export]] bool Field__nullable(const std::shared_ptr& field) { return field->nullable(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Field__type(const std::shared_ptr& field) { return field->type(); } + +#endif diff --git a/r/src/generated.cpp b/r/src/generated.cpp new file mode 100644 index 00000000000..998f3f97a88 --- /dev/null +++ b/r/src/generated.cpp @@ -0,0 +1,3603 @@ +// Generated by using data-raw/codegen.R -> do not edit by hand +#include "./arrow_types.h" +#include + +using namespace Rcpp; + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__Slice1(const std::shared_ptr& array, int offset); +SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Slice1( array, offset))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__Slice2(const std::shared_ptr& array, int offset, int length); +SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp); +Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Slice2( array, offset, length))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Array__IsNull(const std::shared_ptr& x, int i); +SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__IsNull( x, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Array__IsValid(const std::shared_ptr& x, int i); +SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__IsValid( x, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Array__length(const std::shared_ptr& x); +SEXP _arrow_Array__length(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__length( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__length(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Array__offset(const std::shared_ptr& x); +SEXP _arrow_Array__offset(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__offset( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__offset(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Array__null_count(const std::shared_ptr& x); +SEXP _arrow_Array__null_count(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__null_count( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__null_count(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__type(const std::shared_ptr& x); +SEXP _arrow_Array__type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__type( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string Array__ToString(const std::shared_ptr& x); +SEXP _arrow_Array__ToString(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__ToString( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__ToString(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::Type::type Array__type_id(const std::shared_ptr& x); +SEXP _arrow_Array__type_id(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__type_id( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__type_id(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Array__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); +SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); +Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Equals( lhs, rhs))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Array__ApproxEquals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); +SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); +Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__ApproxEquals( lhs, rhs))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__data(const std::shared_ptr& array); +SEXP _arrow_Array__data(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__data( array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__data(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Array__RangeEquals(const std::shared_ptr& self, const std::shared_ptr& other, int start_idx, int end_idx, int other_start_idx); +SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); +Rcpp::traits::input_parameter&>::type other(other_sexp); +Rcpp::traits::input_parameter::type start_idx(start_idx_sexp); +Rcpp::traits::input_parameter::type end_idx(end_idx_sexp); +Rcpp::traits::input_parameter::type other_start_idx(other_start_idx_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__RangeEquals( self, other, start_idx, end_idx, other_start_idx))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +LogicalVector Array__Mask(const std::shared_ptr& array); +SEXP _arrow_Array__Mask(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Mask( array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__Mask(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr DictionaryArray__indices(const std::shared_ptr& array); +SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryArray__indices( array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr DictionaryArray__dictionary(const std::shared_ptr& array); +SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryArray__dictionary( array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +SEXP Array__as_vector(const std::shared_ptr& array); +SEXP _arrow_Array__as_vector(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__as_vector( array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__as_vector(SEXP array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__as_vector( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& batch, bool use_threads); +SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); +Rcpp::traits::input_parameter::type use_threads(use_threads_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__to_dataframe( batch, use_threads))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +Rcpp::List Table__to_dataframe(const std::shared_ptr& table, bool use_threads); +SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); +Rcpp::traits::input_parameter::type use_threads(use_threads_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__to_dataframe( table, use_threads))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__infer_type(SEXP x); +SEXP _arrow_Array__infer_type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__infer_type( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__infer_type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__from_vector(SEXP x, SEXP s_type); +SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp); +Rcpp::traits::input_parameter::type s_type(s_type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__from_vector( x, s_type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, SEXP s_type); +SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type chunks(chunks_sexp); +Rcpp::traits::input_parameter::type s_type(s_type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__from_list( chunks, s_type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ArrayData__get_type(const std::shared_ptr& x); +SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_type( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ArrayData__get_length(const std::shared_ptr& x); +SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_length( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ArrayData__get_null_count(const std::shared_ptr& x); +SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_null_count( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ArrayData__get_offset(const std::shared_ptr& x); +SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_offset( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +List ArrayData__buffers(const std::shared_ptr& x); +SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__buffers( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Buffer__is_mutable(const std::shared_ptr& buffer); +SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__is_mutable( buffer))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void Buffer__ZeroPadding(const std::shared_ptr& buffer); +SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Buffer__ZeroPadding( buffer); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t Buffer__capacity(const std::shared_ptr& buffer); +SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__capacity( buffer))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t Buffer__size(const std::shared_ptr& buffer); +SEXP _arrow_Buffer__size(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__size( buffer))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Buffer__size(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr r___RBuffer__initialize(SEXP x); +SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(r___RBuffer__initialize( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ChunkedArray__length(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__length( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ChunkedArray__null_count(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__null_count( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ChunkedArray__num_chunks(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__num_chunks( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkedArray__chunk(const std::shared_ptr& chunked_array, int i); +SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__chunk( chunked_array, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +List ChunkedArray__chunks(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__chunks( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkedArray__type(const std::shared_ptr& chunked_array); +SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__type( chunked_array))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkArray__Slice1(const std::shared_ptr& chunked_array, int offset); +SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkArray__Slice1( chunked_array, offset))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkArray__Slice2(const std::shared_ptr& chunked_array, int offset, int length); +SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp); +Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkArray__Slice2( chunked_array, offset, length))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Column__length(const std::shared_ptr& column); +SEXP _arrow_Column__length(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__length( column))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Column__length(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Column__null_count(const std::shared_ptr& column); +SEXP _arrow_Column__null_count(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__null_count( column))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Column__null_count(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Column__type(const std::shared_ptr& column); +SEXP _arrow_Column__type(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__type( column))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Column__type(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Column__data(const std::shared_ptr& column); +SEXP _arrow_Column__data(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__data( column))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Column__data(SEXP column_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr util___Codec__Create(arrow::Compression::type codec); +SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type codec(codec_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(util___Codec__Create( codec))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___CompressedOutputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); +SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type codec(codec_sexp); +Rcpp::traits::input_parameter&>::type raw(raw_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___CompressedOutputStream__Make( codec, raw))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___CompressedInputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); +SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type codec(codec_sexp); +Rcpp::traits::input_parameter&>::type raw(raw_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___CompressedInputStream__Make( codec, raw))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr compute___CastOptions__initialize(bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate); +SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type allow_int_overflow(allow_int_overflow_sexp); +Rcpp::traits::input_parameter::type allow_time_truncate(allow_time_truncate_sexp); +Rcpp::traits::input_parameter::type allow_float_truncate(allow_float_truncate_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(compute___CastOptions__initialize( allow_int_overflow, allow_time_truncate, allow_float_truncate))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Array__cast(const std::shared_ptr& array, const std::shared_ptr& target_type, const std::shared_ptr& options); +SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); +Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); +Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__cast( array, target_type, options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ChunkedArray__cast(const std::shared_ptr& chunked_array, const std::shared_ptr& target_type, const std::shared_ptr& options); +SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); +Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); +Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__cast( chunked_array, target_type, options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__cast(const std::shared_ptr& batch, const std::shared_ptr& schema, const std::shared_ptr& options); +SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp); +Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__cast( batch, schema, options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__cast(const std::shared_ptr& table, const std::shared_ptr& schema, const std::shared_ptr& options); +SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp); +Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__cast( table, schema, options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr csv___ReadOptions__initialize(List_ options); +SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ReadOptions__initialize( options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr csv___ParseOptions__initialize(List_ options); +SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ParseOptions__initialize( options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr csv___ConvertOptions__initialize(List_ options); +SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ConvertOptions__initialize( options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr csv___TableReader__Make(const std::shared_ptr& input, const std::shared_ptr& read_options, const std::shared_ptr& parse_options, const std::shared_ptr& convert_options); +SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type input(input_sexp); +Rcpp::traits::input_parameter&>::type read_options(read_options_sexp); +Rcpp::traits::input_parameter&>::type parse_options(parse_options_sexp); +Rcpp::traits::input_parameter&>::type convert_options(convert_options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___TableReader__Make( input, read_options, parse_options, convert_options))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr csv___TableReader__Read(const std::shared_ptr& table_reader); +SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table_reader(table_reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___TableReader__Read( table_reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool shared_ptr_is_null(SEXP xp); +SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type xp(xp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(shared_ptr_is_null( xp))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool unique_ptr_is_null(SEXP xp); +SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type xp(xp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(unique_ptr_is_null( xp))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Int8__initialize(); +SEXP _arrow_Int8__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int8__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Int8__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Int16__initialize(); +SEXP _arrow_Int16__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int16__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Int16__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Int32__initialize(); +SEXP _arrow_Int32__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int32__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Int32__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Int64__initialize(); +SEXP _arrow_Int64__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int64__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Int64__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr UInt8__initialize(); +SEXP _arrow_UInt8__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt8__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_UInt8__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr UInt16__initialize(); +SEXP _arrow_UInt16__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt16__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_UInt16__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr UInt32__initialize(); +SEXP _arrow_UInt32__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt32__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_UInt32__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr UInt64__initialize(); +SEXP _arrow_UInt64__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt64__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_UInt64__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Float16__initialize(); +SEXP _arrow_Float16__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float16__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Float16__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Float32__initialize(); +SEXP _arrow_Float32__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float32__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Float32__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Float64__initialize(); +SEXP _arrow_Float64__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float64__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Float64__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Boolean__initialize(); +SEXP _arrow_Boolean__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Boolean__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Boolean__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Utf8__initialize(); +SEXP _arrow_Utf8__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Utf8__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Utf8__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Date32__initialize(); +SEXP _arrow_Date32__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Date32__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Date32__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Date64__initialize(); +SEXP _arrow_Date64__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Date64__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Date64__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Null__initialize(); +SEXP _arrow_Null__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Null__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Null__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Decimal128Type__initialize(int32_t precision, int32_t scale); +SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type precision(precision_sexp); +Rcpp::traits::input_parameter::type scale(scale_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Decimal128Type__initialize( precision, scale))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr FixedSizeBinary__initialize(int32_t byte_width); +SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type byte_width(byte_width_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(FixedSizeBinary__initialize( byte_width))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Timestamp__initialize1(arrow::TimeUnit::type unit); +SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Timestamp__initialize1( unit))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Timestamp__initialize2(arrow::TimeUnit::type unit, const std::string& timezone); +SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp); +Rcpp::traits::input_parameter::type timezone(timezone_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Timestamp__initialize2( unit, timezone))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Time32__initialize(arrow::TimeUnit::type unit); +SEXP _arrow_Time32__initialize(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Time32__initialize( unit))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Time32__initialize(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Time64__initialize(arrow::TimeUnit::type unit); +SEXP _arrow_Time64__initialize(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Time64__initialize( unit))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Time64__initialize(SEXP unit_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +SEXP list__(SEXP x); +SEXP _arrow_list__(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(list__( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_list__(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr struct_(List fields); +SEXP _arrow_struct_(SEXP fields_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type fields(fields_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(struct_( fields))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_struct_(SEXP fields_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string DataType__ToString(const std::shared_ptr& type); +SEXP _arrow_DataType__ToString(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__ToString( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__ToString(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string DataType__name(const std::shared_ptr& type); +SEXP _arrow_DataType__name(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__name( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__name(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool DataType__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); +SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); +Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__Equals( lhs, rhs))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int DataType__num_children(const std::shared_ptr& type); +SEXP _arrow_DataType__num_children(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__num_children( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__num_children(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +List DataType__children_pointer(const std::shared_ptr& type); +SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__children_pointer( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::Type::type DataType__id(const std::shared_ptr& type); +SEXP _arrow_DataType__id(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__id( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DataType__id(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr schema_(List fields); +SEXP _arrow_schema_(SEXP fields_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type fields(fields_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(schema_( fields))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_schema_(SEXP fields_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string Schema__ToString(const std::shared_ptr& s); +SEXP _arrow_Schema__ToString(SEXP s_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__ToString( s))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Schema__ToString(SEXP s_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Schema__num_fields(const std::shared_ptr& s); +SEXP _arrow_Schema__num_fields(SEXP s_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__num_fields( s))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Schema__num_fields(SEXP s_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Schema__field(const std::shared_ptr& s, int i); +SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__field( s, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +CharacterVector Schema__names(const std::shared_ptr& schema); +SEXP _arrow_Schema__names(SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__names( schema))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Schema__names(SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string ListType__ToString(const std::shared_ptr& type); +SEXP _arrow_ListType__ToString(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ListType__ToString( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ListType__ToString(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int FixedWidthType__bit_width(const std::shared_ptr& type); +SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(FixedWidthType__bit_width( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::DateUnit DateType__unit(const std::shared_ptr& type); +SEXP _arrow_DateType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DateType__unit( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DateType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::TimeUnit::type TimeType__unit(const std::shared_ptr& type); +SEXP _arrow_TimeType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimeType__unit( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_TimeType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int32_t DecimalType__precision(const std::shared_ptr& type); +SEXP _arrow_DecimalType__precision(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DecimalType__precision( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DecimalType__precision(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int32_t DecimalType__scale(const std::shared_ptr& type); +SEXP _arrow_DecimalType__scale(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DecimalType__scale( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DecimalType__scale(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string TimestampType__timezone(const std::shared_ptr& type); +SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimestampType__timezone( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::TimeUnit::type TimestampType__unit(const std::shared_ptr& type); +SEXP _arrow_TimestampType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimestampType__unit( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_TimestampType__unit(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr DictionaryType__initialize(const std::shared_ptr& index_type, const std::shared_ptr& value_type, bool ordered); +SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type index_type(index_type_sexp); +Rcpp::traits::input_parameter&>::type value_type(value_type_sexp); +Rcpp::traits::input_parameter::type ordered(ordered_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__initialize( index_type, value_type, ordered))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr DictionaryType__index_type(const std::shared_ptr& type); +SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__index_type( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr DictionaryType__value_type(const std::shared_ptr& type); +SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__value_type( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string DictionaryType__name(const std::shared_ptr& type); +SEXP _arrow_DictionaryType__name(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__name( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryType__name(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool DictionaryType__ordered(const std::shared_ptr& type); +SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__ordered( type))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___feather___TableWriter__SetDescription(const std::unique_ptr& writer, const std::string& description); +SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); +Rcpp::traits::input_parameter::type description(description_sexp);ipc___feather___TableWriter__SetDescription( writer, description); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___feather___TableWriter__SetNumRows(const std::unique_ptr& writer, int64_t num_rows); +SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); +Rcpp::traits::input_parameter::type num_rows(num_rows_sexp);ipc___feather___TableWriter__SetNumRows( writer, num_rows); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___feather___TableWriter__Append(const std::unique_ptr& writer, const std::string& name, const std::shared_ptr& values); +SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); +Rcpp::traits::input_parameter::type name(name_sexp); +Rcpp::traits::input_parameter&>::type values(values_sexp);ipc___feather___TableWriter__Append( writer, name, values); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___feather___TableWriter__Finalize(const std::unique_ptr& writer); +SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp);ipc___feather___TableWriter__Finalize( writer); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr ipc___feather___TableWriter__Open(const std::shared_ptr& stream); +SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableWriter__Open( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___TableWriter__RecordBatch__WriteFeather(const std::unique_ptr& writer, const std::shared_ptr& batch); +SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); +Rcpp::traits::input_parameter&>::type batch(batch_sexp);ipc___TableWriter__RecordBatch__WriteFeather( writer, batch); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string ipc___feather___TableReader__GetDescription(const std::unique_ptr& reader); +SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetDescription( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool ipc___feather___TableReader__HasDescription(const std::unique_ptr& reader); +SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__HasDescription( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ipc___feather___TableReader__version(const std::unique_ptr& reader); +SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__version( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t ipc___feather___TableReader__num_rows(const std::unique_ptr& reader); +SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__num_rows( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t ipc___feather___TableReader__num_columns(const std::unique_ptr& reader); +SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__num_columns( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string ipc___feather___TableReader__GetColumnName(const std::unique_ptr& reader, int i); +SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetColumnName( reader, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___feather___TableReader__GetColumn(const std::unique_ptr& reader, int i); +SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetColumn( reader, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___feather___TableReader__Read(const std::unique_ptr& reader, SEXP columns); +SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); +Rcpp::traits::input_parameter::type columns(columns_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__Read( reader, columns))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr ipc___feather___TableReader__Open(const std::shared_ptr& stream); +SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__Open( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Field__initialize(const std::string& name, const std::shared_ptr& field, bool nullable); +SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type name(name_sexp); +Rcpp::traits::input_parameter&>::type field(field_sexp); +Rcpp::traits::input_parameter::type nullable(nullable_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__initialize( name, field, nullable))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string Field__ToString(const std::shared_ptr& field); +SEXP _arrow_Field__ToString(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__ToString( field))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__ToString(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string Field__name(const std::shared_ptr& field); +SEXP _arrow_Field__name(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__name( field))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__name(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Field__Equals(const std::shared_ptr& field, const std::shared_ptr& other); +SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); +Rcpp::traits::input_parameter&>::type other(other_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__Equals( field, other))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool Field__nullable(const std::shared_ptr& field); +SEXP _arrow_Field__nullable(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__nullable( field))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__nullable(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Field__type(const std::shared_ptr& field); +SEXP _arrow_Field__type(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__type( field))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Field__type(SEXP field_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___Readable__Read(const std::shared_ptr& x, int64_t nbytes); +SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter::type nbytes(nbytes_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___Readable__Read( x, nbytes))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___InputStream__Close(const std::shared_ptr& x); +SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);io___InputStream__Close( x); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___OutputStream__Close(const std::shared_ptr& x); +SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);io___OutputStream__Close( x); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___RandomAccessFile__GetSize(const std::shared_ptr& x); +SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__GetSize( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool io___RandomAccessFile__supports_zero_copy(const std::shared_ptr& x); +SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__supports_zero_copy( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___RandomAccessFile__Seek(const std::shared_ptr& x, int64_t position); +SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter::type position(position_sexp);io___RandomAccessFile__Seek( x, position); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___RandomAccessFile__Tell(const std::shared_ptr& x); +SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__Tell( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___MemoryMappedFile__Create(const std::string& path, int64_t size); +SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); +Rcpp::traits::input_parameter::type size(size_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MemoryMappedFile__Create( path, size))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___MemoryMappedFile__Open(const std::string& path, arrow::io::FileMode::type mode); +SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); +Rcpp::traits::input_parameter::type mode(mode_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MemoryMappedFile__Open( path, mode))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___MemoryMappedFile__Resize(const std::shared_ptr& x, int64_t size); +SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter::type size(size_sexp);io___MemoryMappedFile__Resize( x, size); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___ReadableFile__Open(const std::string& path); +SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___ReadableFile__Open( path))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___BufferReader__initialize(const std::shared_ptr& buffer); +SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferReader__initialize( buffer))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___Writable__write(const std::shared_ptr& stream, const std::shared_ptr& buf); +SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); +Rcpp::traits::input_parameter&>::type buf(buf_sexp);io___Writable__write( stream, buf); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___OutputStream__Tell(const std::shared_ptr& stream); +SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___OutputStream__Tell( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___FileOutputStream__Open(const std::string& path); +SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___FileOutputStream__Open( path))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___BufferOutputStream__Create(int64_t initial_capacity); +SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type initial_capacity(initial_capacity_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Create( initial_capacity))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___BufferOutputStream__capacity(const std::shared_ptr& stream); +SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__capacity( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___BufferOutputStream__Finish(const std::shared_ptr& stream); +SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Finish( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___BufferOutputStream__Tell(const std::shared_ptr& stream); +SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Tell( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void io___BufferOutputStream__Write(const std::shared_ptr& stream, RawVector_ bytes); +SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); +Rcpp::traits::input_parameter::type bytes(bytes_sexp);io___BufferOutputStream__Write( stream, bytes); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___MockOutputStream__initialize(); +SEXP _arrow_io___MockOutputStream__initialize(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MockOutputStream__initialize( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___MockOutputStream__initialize(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t io___MockOutputStream__GetExtentBytesWritten(const std::shared_ptr& stream); +SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MockOutputStream__GetExtentBytesWritten( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr io___FixedSizeBufferWriter__initialize(const std::shared_ptr& buffer); +SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___FixedSizeBufferWriter__initialize( buffer))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr MemoryPool__default(); +SEXP _arrow_MemoryPool__default(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__default( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_MemoryPool__default(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int MemoryPool__bytes_allocated(const std::shared_ptr& pool); +SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type pool(pool_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__bytes_allocated( pool))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int MemoryPool__max_memory(const std::shared_ptr& pool); +SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type pool(pool_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__max_memory( pool))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t ipc___Message__body_length(const std::unique_ptr& message); +SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__body_length( message))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___Message__metadata(const std::unique_ptr& message); +SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__metadata( message))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___Message__body(const std::unique_ptr& message); +SEXP _arrow_ipc___Message__body(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__body( message))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__body(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int64_t ipc___Message__Verify(const std::unique_ptr& message); +SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__Verify( message))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::ipc::Message::Type ipc___Message__type(const std::unique_ptr& message); +SEXP _arrow_ipc___Message__type(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__type( message))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__type(SEXP message_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool ipc___Message__Equals(const std::unique_ptr& x, const std::unique_ptr& y); +SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); +Rcpp::traits::input_parameter&>::type y(y_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__Equals( x, y))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___ReadRecordBatch__Message__Schema(const std::unique_ptr& message, const std::shared_ptr& schema); +SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadRecordBatch__Message__Schema( message, schema))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___ReadSchema_InputStream(const std::shared_ptr& stream); +SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadSchema_InputStream( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr ipc___MessageReader__Open(const std::shared_ptr& stream); +SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___MessageReader__Open( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr ipc___MessageReader__ReadNextMessage(const std::unique_ptr& reader); +SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___MessageReader__ReadNextMessage( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::unique_ptr ipc___ReadMessage(const std::shared_ptr& stream); +SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadMessage( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr read_parquet_file(std::string filename); +SEXP _arrow_read_parquet_file(SEXP filename_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type filename(filename_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(read_parquet_file( filename))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_read_parquet_file(SEXP filename_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int RecordBatch__num_columns(const std::shared_ptr& x); +SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__num_columns( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int RecordBatch__num_rows(const std::shared_ptr& x); +SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__num_rows( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__schema(const std::shared_ptr& x); +SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__schema( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +arrow::ArrayVector RecordBatch__columns(const std::shared_ptr& batch); +SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__columns( batch))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__column(const std::shared_ptr& batch, int i); +SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__column( batch, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl); +SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type tbl(tbl_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__from_dataframe( tbl))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other); +SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); +Rcpp::traits::input_parameter&>::type other(other_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Equals( self, other))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__RemoveColumn(const std::shared_ptr& batch, int i); +SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__RemoveColumn( batch, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::string RecordBatch__column_name(const std::shared_ptr& batch, int i); +SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__column_name( batch, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +Rcpp::CharacterVector RecordBatch__names(const std::shared_ptr& batch); +SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__names( batch))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__Slice1(const std::shared_ptr& self, int offset); +SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Slice1( self, offset))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__Slice2(const std::shared_ptr& self, int offset, int length); +SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); +Rcpp::traits::input_parameter::type offset(offset_sexp); +Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Slice2( self, offset, length))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +Rcpp::RawVector ipc___SerializeRecordBatch__Raw(const std::shared_ptr& batch); +SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___SerializeRecordBatch__Raw( batch))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___ReadRecordBatch__InputStream__Schema(const std::shared_ptr& stream, const std::shared_ptr& schema); +SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadRecordBatch__InputStream__Schema( stream, schema))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatchReader__schema(const std::shared_ptr& reader); +SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatchReader__schema( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatchReader__ReadNext(const std::shared_ptr& reader); +SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatchReader__ReadNext( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchStreamReader__Open(const std::shared_ptr& stream); +SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamReader__Open( stream))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::vector> ipc___RecordBatchStreamReader__batches(const std::shared_ptr& reader); +SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamReader__batches( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchFileReader__schema(const std::shared_ptr& reader); +SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__schema( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int ipc___RecordBatchFileReader__num_record_batches(const std::shared_ptr& reader); +SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__num_record_batches( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch(const std::shared_ptr& reader, int i); +SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__ReadRecordBatch( reader, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchFileReader__Open(const std::shared_ptr& file); +SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type file(file_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__Open( file))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__from_RecordBatchFileReader(const std::shared_ptr& reader); +SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_RecordBatchFileReader( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__from_RecordBatchStreamReader(const std::shared_ptr& reader); +SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_RecordBatchStreamReader( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::vector> ipc___RecordBatchFileReader__batches(const std::shared_ptr& reader); +SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__batches( reader))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___RecordBatchWriter__WriteRecordBatch(const std::shared_ptr& batch_writer, const std::shared_ptr& batch); +SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); +Rcpp::traits::input_parameter&>::type batch(batch_sexp);ipc___RecordBatchWriter__WriteRecordBatch( batch_writer, batch); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___RecordBatchWriter__WriteTable(const std::shared_ptr& batch_writer, const std::shared_ptr& table); +SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); +Rcpp::traits::input_parameter&>::type table(table_sexp);ipc___RecordBatchWriter__WriteTable( batch_writer, table); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void ipc___RecordBatchWriter__Close(const std::shared_ptr& batch_writer); +SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp);ipc___RecordBatchWriter__Close( batch_writer); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchFileWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); +SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileWriter__Open( stream, schema))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr ipc___RecordBatchStreamWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); +SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); +Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamWriter__Open( stream, schema))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__from_dataframe(DataFrame tbl); +SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type tbl(tbl_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_dataframe( tbl))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Table__num_columns(const std::shared_ptr& x); +SEXP _arrow_Table__num_columns(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__num_columns( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__num_columns(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int Table__num_rows(const std::shared_ptr& x); +SEXP _arrow_Table__num_rows(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__num_rows( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__num_rows(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__schema(const std::shared_ptr& x); +SEXP _arrow_Table__schema(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__schema( x))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__schema(SEXP x_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__column(const std::shared_ptr& table, int i); +SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); +Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__column( table, i))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +std::vector> Table__columns(const std::shared_ptr& table); +SEXP _arrow_Table__columns(SEXP table_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__columns( table))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__columns(SEXP table_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +int GetCpuThreadPoolCapacity(); +SEXP _arrow_GetCpuThreadPoolCapacity(){ + BEGIN_RCPP + Rcpp::Shield rcpp_result_gen(Rcpp::wrap(GetCpuThreadPoolCapacity( ))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_GetCpuThreadPoolCapacity(){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + +#if defined(ARROW_R_WITH_ARROW) +void SetCpuThreadPoolCapacity(int threads); +SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type threads(threads_sexp);SetCpuThreadPoolCapacity( threads); +return R_NilValue; + END_RCPP +} +#else +SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + + +extern "C" SEXP _arrow_available() { +return Rf_ScalarLogical( +#if defined(ARROW_R_WITH_ARROW) + TRUE +#else + FALSE +#endif +); +} + +static const R_CallMethodDef arrow_CallEntries[] = { + { "_arrow_available", (DL_FUNC)& _arrow_available, 0 }, + { "_arrow_Array__Slice1", (DL_FUNC)& _arrow_Array__Slice1, 2 }, + { "_arrow_Array__Slice2", (DL_FUNC)& _arrow_Array__Slice2, 3 }, + { "_arrow_Array__IsNull", (DL_FUNC)& _arrow_Array__IsNull, 2 }, + { "_arrow_Array__IsValid", (DL_FUNC)& _arrow_Array__IsValid, 2 }, + { "_arrow_Array__length", (DL_FUNC)& _arrow_Array__length, 1 }, + { "_arrow_Array__offset", (DL_FUNC)& _arrow_Array__offset, 1 }, + { "_arrow_Array__null_count", (DL_FUNC)& _arrow_Array__null_count, 1 }, + { "_arrow_Array__type", (DL_FUNC)& _arrow_Array__type, 1 }, + { "_arrow_Array__ToString", (DL_FUNC)& _arrow_Array__ToString, 1 }, + { "_arrow_Array__type_id", (DL_FUNC)& _arrow_Array__type_id, 1 }, + { "_arrow_Array__Equals", (DL_FUNC)& _arrow_Array__Equals, 2 }, + { "_arrow_Array__ApproxEquals", (DL_FUNC)& _arrow_Array__ApproxEquals, 2 }, + { "_arrow_Array__data", (DL_FUNC)& _arrow_Array__data, 1 }, + { "_arrow_Array__RangeEquals", (DL_FUNC)& _arrow_Array__RangeEquals, 5 }, + { "_arrow_Array__Mask", (DL_FUNC)& _arrow_Array__Mask, 1 }, + { "_arrow_DictionaryArray__indices", (DL_FUNC)& _arrow_DictionaryArray__indices, 1 }, + { "_arrow_DictionaryArray__dictionary", (DL_FUNC)& _arrow_DictionaryArray__dictionary, 1 }, + { "_arrow_Array__as_vector", (DL_FUNC)& _arrow_Array__as_vector, 1 }, + { "_arrow_ChunkedArray__as_vector", (DL_FUNC)& _arrow_ChunkedArray__as_vector, 1 }, + { "_arrow_RecordBatch__to_dataframe", (DL_FUNC)& _arrow_RecordBatch__to_dataframe, 2 }, + { "_arrow_Table__to_dataframe", (DL_FUNC)& _arrow_Table__to_dataframe, 2 }, + { "_arrow_Array__infer_type", (DL_FUNC)& _arrow_Array__infer_type, 1 }, + { "_arrow_Array__from_vector", (DL_FUNC)& _arrow_Array__from_vector, 2 }, + { "_arrow_ChunkedArray__from_list", (DL_FUNC)& _arrow_ChunkedArray__from_list, 2 }, + { "_arrow_ArrayData__get_type", (DL_FUNC)& _arrow_ArrayData__get_type, 1 }, + { "_arrow_ArrayData__get_length", (DL_FUNC)& _arrow_ArrayData__get_length, 1 }, + { "_arrow_ArrayData__get_null_count", (DL_FUNC)& _arrow_ArrayData__get_null_count, 1 }, + { "_arrow_ArrayData__get_offset", (DL_FUNC)& _arrow_ArrayData__get_offset, 1 }, + { "_arrow_ArrayData__buffers", (DL_FUNC)& _arrow_ArrayData__buffers, 1 }, + { "_arrow_Buffer__is_mutable", (DL_FUNC)& _arrow_Buffer__is_mutable, 1 }, + { "_arrow_Buffer__ZeroPadding", (DL_FUNC)& _arrow_Buffer__ZeroPadding, 1 }, + { "_arrow_Buffer__capacity", (DL_FUNC)& _arrow_Buffer__capacity, 1 }, + { "_arrow_Buffer__size", (DL_FUNC)& _arrow_Buffer__size, 1 }, + { "_arrow_r___RBuffer__initialize", (DL_FUNC)& _arrow_r___RBuffer__initialize, 1 }, + { "_arrow_ChunkedArray__length", (DL_FUNC)& _arrow_ChunkedArray__length, 1 }, + { "_arrow_ChunkedArray__null_count", (DL_FUNC)& _arrow_ChunkedArray__null_count, 1 }, + { "_arrow_ChunkedArray__num_chunks", (DL_FUNC)& _arrow_ChunkedArray__num_chunks, 1 }, + { "_arrow_ChunkedArray__chunk", (DL_FUNC)& _arrow_ChunkedArray__chunk, 2 }, + { "_arrow_ChunkedArray__chunks", (DL_FUNC)& _arrow_ChunkedArray__chunks, 1 }, + { "_arrow_ChunkedArray__type", (DL_FUNC)& _arrow_ChunkedArray__type, 1 }, + { "_arrow_ChunkArray__Slice1", (DL_FUNC)& _arrow_ChunkArray__Slice1, 2 }, + { "_arrow_ChunkArray__Slice2", (DL_FUNC)& _arrow_ChunkArray__Slice2, 3 }, + { "_arrow_Column__length", (DL_FUNC)& _arrow_Column__length, 1 }, + { "_arrow_Column__null_count", (DL_FUNC)& _arrow_Column__null_count, 1 }, + { "_arrow_Column__type", (DL_FUNC)& _arrow_Column__type, 1 }, + { "_arrow_Column__data", (DL_FUNC)& _arrow_Column__data, 1 }, + { "_arrow_util___Codec__Create", (DL_FUNC)& _arrow_util___Codec__Create, 1 }, + { "_arrow_io___CompressedOutputStream__Make", (DL_FUNC)& _arrow_io___CompressedOutputStream__Make, 2 }, + { "_arrow_io___CompressedInputStream__Make", (DL_FUNC)& _arrow_io___CompressedInputStream__Make, 2 }, + { "_arrow_compute___CastOptions__initialize", (DL_FUNC)& _arrow_compute___CastOptions__initialize, 3 }, + { "_arrow_Array__cast", (DL_FUNC)& _arrow_Array__cast, 3 }, + { "_arrow_ChunkedArray__cast", (DL_FUNC)& _arrow_ChunkedArray__cast, 3 }, + { "_arrow_RecordBatch__cast", (DL_FUNC)& _arrow_RecordBatch__cast, 3 }, + { "_arrow_Table__cast", (DL_FUNC)& _arrow_Table__cast, 3 }, + { "_arrow_csv___ReadOptions__initialize", (DL_FUNC)& _arrow_csv___ReadOptions__initialize, 1 }, + { "_arrow_csv___ParseOptions__initialize", (DL_FUNC)& _arrow_csv___ParseOptions__initialize, 1 }, + { "_arrow_csv___ConvertOptions__initialize", (DL_FUNC)& _arrow_csv___ConvertOptions__initialize, 1 }, + { "_arrow_csv___TableReader__Make", (DL_FUNC)& _arrow_csv___TableReader__Make, 4 }, + { "_arrow_csv___TableReader__Read", (DL_FUNC)& _arrow_csv___TableReader__Read, 1 }, + { "_arrow_shared_ptr_is_null", (DL_FUNC)& _arrow_shared_ptr_is_null, 1 }, + { "_arrow_unique_ptr_is_null", (DL_FUNC)& _arrow_unique_ptr_is_null, 1 }, + { "_arrow_Int8__initialize", (DL_FUNC)& _arrow_Int8__initialize, 0 }, + { "_arrow_Int16__initialize", (DL_FUNC)& _arrow_Int16__initialize, 0 }, + { "_arrow_Int32__initialize", (DL_FUNC)& _arrow_Int32__initialize, 0 }, + { "_arrow_Int64__initialize", (DL_FUNC)& _arrow_Int64__initialize, 0 }, + { "_arrow_UInt8__initialize", (DL_FUNC)& _arrow_UInt8__initialize, 0 }, + { "_arrow_UInt16__initialize", (DL_FUNC)& _arrow_UInt16__initialize, 0 }, + { "_arrow_UInt32__initialize", (DL_FUNC)& _arrow_UInt32__initialize, 0 }, + { "_arrow_UInt64__initialize", (DL_FUNC)& _arrow_UInt64__initialize, 0 }, + { "_arrow_Float16__initialize", (DL_FUNC)& _arrow_Float16__initialize, 0 }, + { "_arrow_Float32__initialize", (DL_FUNC)& _arrow_Float32__initialize, 0 }, + { "_arrow_Float64__initialize", (DL_FUNC)& _arrow_Float64__initialize, 0 }, + { "_arrow_Boolean__initialize", (DL_FUNC)& _arrow_Boolean__initialize, 0 }, + { "_arrow_Utf8__initialize", (DL_FUNC)& _arrow_Utf8__initialize, 0 }, + { "_arrow_Date32__initialize", (DL_FUNC)& _arrow_Date32__initialize, 0 }, + { "_arrow_Date64__initialize", (DL_FUNC)& _arrow_Date64__initialize, 0 }, + { "_arrow_Null__initialize", (DL_FUNC)& _arrow_Null__initialize, 0 }, + { "_arrow_Decimal128Type__initialize", (DL_FUNC)& _arrow_Decimal128Type__initialize, 2 }, + { "_arrow_FixedSizeBinary__initialize", (DL_FUNC)& _arrow_FixedSizeBinary__initialize, 1 }, + { "_arrow_Timestamp__initialize1", (DL_FUNC)& _arrow_Timestamp__initialize1, 1 }, + { "_arrow_Timestamp__initialize2", (DL_FUNC)& _arrow_Timestamp__initialize2, 2 }, + { "_arrow_Time32__initialize", (DL_FUNC)& _arrow_Time32__initialize, 1 }, + { "_arrow_Time64__initialize", (DL_FUNC)& _arrow_Time64__initialize, 1 }, + { "_arrow_list__", (DL_FUNC)& _arrow_list__, 1 }, + { "_arrow_struct_", (DL_FUNC)& _arrow_struct_, 1 }, + { "_arrow_DataType__ToString", (DL_FUNC)& _arrow_DataType__ToString, 1 }, + { "_arrow_DataType__name", (DL_FUNC)& _arrow_DataType__name, 1 }, + { "_arrow_DataType__Equals", (DL_FUNC)& _arrow_DataType__Equals, 2 }, + { "_arrow_DataType__num_children", (DL_FUNC)& _arrow_DataType__num_children, 1 }, + { "_arrow_DataType__children_pointer", (DL_FUNC)& _arrow_DataType__children_pointer, 1 }, + { "_arrow_DataType__id", (DL_FUNC)& _arrow_DataType__id, 1 }, + { "_arrow_schema_", (DL_FUNC)& _arrow_schema_, 1 }, + { "_arrow_Schema__ToString", (DL_FUNC)& _arrow_Schema__ToString, 1 }, + { "_arrow_Schema__num_fields", (DL_FUNC)& _arrow_Schema__num_fields, 1 }, + { "_arrow_Schema__field", (DL_FUNC)& _arrow_Schema__field, 2 }, + { "_arrow_Schema__names", (DL_FUNC)& _arrow_Schema__names, 1 }, + { "_arrow_ListType__ToString", (DL_FUNC)& _arrow_ListType__ToString, 1 }, + { "_arrow_FixedWidthType__bit_width", (DL_FUNC)& _arrow_FixedWidthType__bit_width, 1 }, + { "_arrow_DateType__unit", (DL_FUNC)& _arrow_DateType__unit, 1 }, + { "_arrow_TimeType__unit", (DL_FUNC)& _arrow_TimeType__unit, 1 }, + { "_arrow_DecimalType__precision", (DL_FUNC)& _arrow_DecimalType__precision, 1 }, + { "_arrow_DecimalType__scale", (DL_FUNC)& _arrow_DecimalType__scale, 1 }, + { "_arrow_TimestampType__timezone", (DL_FUNC)& _arrow_TimestampType__timezone, 1 }, + { "_arrow_TimestampType__unit", (DL_FUNC)& _arrow_TimestampType__unit, 1 }, + { "_arrow_DictionaryType__initialize", (DL_FUNC)& _arrow_DictionaryType__initialize, 3 }, + { "_arrow_DictionaryType__index_type", (DL_FUNC)& _arrow_DictionaryType__index_type, 1 }, + { "_arrow_DictionaryType__value_type", (DL_FUNC)& _arrow_DictionaryType__value_type, 1 }, + { "_arrow_DictionaryType__name", (DL_FUNC)& _arrow_DictionaryType__name, 1 }, + { "_arrow_DictionaryType__ordered", (DL_FUNC)& _arrow_DictionaryType__ordered, 1 }, + { "_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetDescription, 2 }, + { "_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetNumRows, 2 }, + { "_arrow_ipc___feather___TableWriter__Append", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Append, 3 }, + { "_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Finalize, 1 }, + { "_arrow_ipc___feather___TableWriter__Open", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Open, 1 }, + { "_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC)& _arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2 }, + { "_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetDescription, 1 }, + { "_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__HasDescription, 1 }, + { "_arrow_ipc___feather___TableReader__version", (DL_FUNC)& _arrow_ipc___feather___TableReader__version, 1 }, + { "_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_rows, 1 }, + { "_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_columns, 1 }, + { "_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumnName, 2 }, + { "_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumn, 2 }, + { "_arrow_ipc___feather___TableReader__Read", (DL_FUNC)& _arrow_ipc___feather___TableReader__Read, 2 }, + { "_arrow_ipc___feather___TableReader__Open", (DL_FUNC)& _arrow_ipc___feather___TableReader__Open, 1 }, + { "_arrow_Field__initialize", (DL_FUNC)& _arrow_Field__initialize, 3 }, + { "_arrow_Field__ToString", (DL_FUNC)& _arrow_Field__ToString, 1 }, + { "_arrow_Field__name", (DL_FUNC)& _arrow_Field__name, 1 }, + { "_arrow_Field__Equals", (DL_FUNC)& _arrow_Field__Equals, 2 }, + { "_arrow_Field__nullable", (DL_FUNC)& _arrow_Field__nullable, 1 }, + { "_arrow_Field__type", (DL_FUNC)& _arrow_Field__type, 1 }, + { "_arrow_io___Readable__Read", (DL_FUNC)& _arrow_io___Readable__Read, 2 }, + { "_arrow_io___InputStream__Close", (DL_FUNC)& _arrow_io___InputStream__Close, 1 }, + { "_arrow_io___OutputStream__Close", (DL_FUNC)& _arrow_io___OutputStream__Close, 1 }, + { "_arrow_io___RandomAccessFile__GetSize", (DL_FUNC)& _arrow_io___RandomAccessFile__GetSize, 1 }, + { "_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC)& _arrow_io___RandomAccessFile__supports_zero_copy, 1 }, + { "_arrow_io___RandomAccessFile__Seek", (DL_FUNC)& _arrow_io___RandomAccessFile__Seek, 2 }, + { "_arrow_io___RandomAccessFile__Tell", (DL_FUNC)& _arrow_io___RandomAccessFile__Tell, 1 }, + { "_arrow_io___MemoryMappedFile__Create", (DL_FUNC)& _arrow_io___MemoryMappedFile__Create, 2 }, + { "_arrow_io___MemoryMappedFile__Open", (DL_FUNC)& _arrow_io___MemoryMappedFile__Open, 2 }, + { "_arrow_io___MemoryMappedFile__Resize", (DL_FUNC)& _arrow_io___MemoryMappedFile__Resize, 2 }, + { "_arrow_io___ReadableFile__Open", (DL_FUNC)& _arrow_io___ReadableFile__Open, 1 }, + { "_arrow_io___BufferReader__initialize", (DL_FUNC)& _arrow_io___BufferReader__initialize, 1 }, + { "_arrow_io___Writable__write", (DL_FUNC)& _arrow_io___Writable__write, 2 }, + { "_arrow_io___OutputStream__Tell", (DL_FUNC)& _arrow_io___OutputStream__Tell, 1 }, + { "_arrow_io___FileOutputStream__Open", (DL_FUNC)& _arrow_io___FileOutputStream__Open, 1 }, + { "_arrow_io___BufferOutputStream__Create", (DL_FUNC)& _arrow_io___BufferOutputStream__Create, 1 }, + { "_arrow_io___BufferOutputStream__capacity", (DL_FUNC)& _arrow_io___BufferOutputStream__capacity, 1 }, + { "_arrow_io___BufferOutputStream__Finish", (DL_FUNC)& _arrow_io___BufferOutputStream__Finish, 1 }, + { "_arrow_io___BufferOutputStream__Tell", (DL_FUNC)& _arrow_io___BufferOutputStream__Tell, 1 }, + { "_arrow_io___BufferOutputStream__Write", (DL_FUNC)& _arrow_io___BufferOutputStream__Write, 2 }, + { "_arrow_io___MockOutputStream__initialize", (DL_FUNC)& _arrow_io___MockOutputStream__initialize, 0 }, + { "_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC)& _arrow_io___MockOutputStream__GetExtentBytesWritten, 1 }, + { "_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC)& _arrow_io___FixedSizeBufferWriter__initialize, 1 }, + { "_arrow_MemoryPool__default", (DL_FUNC)& _arrow_MemoryPool__default, 0 }, + { "_arrow_MemoryPool__bytes_allocated", (DL_FUNC)& _arrow_MemoryPool__bytes_allocated, 1 }, + { "_arrow_MemoryPool__max_memory", (DL_FUNC)& _arrow_MemoryPool__max_memory, 1 }, + { "_arrow_ipc___Message__body_length", (DL_FUNC)& _arrow_ipc___Message__body_length, 1 }, + { "_arrow_ipc___Message__metadata", (DL_FUNC)& _arrow_ipc___Message__metadata, 1 }, + { "_arrow_ipc___Message__body", (DL_FUNC)& _arrow_ipc___Message__body, 1 }, + { "_arrow_ipc___Message__Verify", (DL_FUNC)& _arrow_ipc___Message__Verify, 1 }, + { "_arrow_ipc___Message__type", (DL_FUNC)& _arrow_ipc___Message__type, 1 }, + { "_arrow_ipc___Message__Equals", (DL_FUNC)& _arrow_ipc___Message__Equals, 2 }, + { "_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__Message__Schema, 2 }, + { "_arrow_ipc___ReadSchema_InputStream", (DL_FUNC)& _arrow_ipc___ReadSchema_InputStream, 1 }, + { "_arrow_ipc___MessageReader__Open", (DL_FUNC)& _arrow_ipc___MessageReader__Open, 1 }, + { "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC)& _arrow_ipc___MessageReader__ReadNextMessage, 1 }, + { "_arrow_ipc___ReadMessage", (DL_FUNC)& _arrow_ipc___ReadMessage, 1 }, + { "_arrow_read_parquet_file", (DL_FUNC)& _arrow_read_parquet_file, 1 }, + { "_arrow_RecordBatch__num_columns", (DL_FUNC)& _arrow_RecordBatch__num_columns, 1 }, + { "_arrow_RecordBatch__num_rows", (DL_FUNC)& _arrow_RecordBatch__num_rows, 1 }, + { "_arrow_RecordBatch__schema", (DL_FUNC)& _arrow_RecordBatch__schema, 1 }, + { "_arrow_RecordBatch__columns", (DL_FUNC)& _arrow_RecordBatch__columns, 1 }, + { "_arrow_RecordBatch__column", (DL_FUNC)& _arrow_RecordBatch__column, 2 }, + { "_arrow_RecordBatch__from_dataframe", (DL_FUNC)& _arrow_RecordBatch__from_dataframe, 1 }, + { "_arrow_RecordBatch__Equals", (DL_FUNC)& _arrow_RecordBatch__Equals, 2 }, + { "_arrow_RecordBatch__RemoveColumn", (DL_FUNC)& _arrow_RecordBatch__RemoveColumn, 2 }, + { "_arrow_RecordBatch__column_name", (DL_FUNC)& _arrow_RecordBatch__column_name, 2 }, + { "_arrow_RecordBatch__names", (DL_FUNC)& _arrow_RecordBatch__names, 1 }, + { "_arrow_RecordBatch__Slice1", (DL_FUNC)& _arrow_RecordBatch__Slice1, 2 }, + { "_arrow_RecordBatch__Slice2", (DL_FUNC)& _arrow_RecordBatch__Slice2, 3 }, + { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC)& _arrow_ipc___SerializeRecordBatch__Raw, 1 }, + { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__InputStream__Schema, 2 }, + { "_arrow_RecordBatchReader__schema", (DL_FUNC)& _arrow_RecordBatchReader__schema, 1 }, + { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC)& _arrow_RecordBatchReader__ReadNext, 1 }, + { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__Open, 1 }, + { "_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__batches, 1 }, + { "_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__schema, 1 }, + { "_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__num_record_batches, 1 }, + { "_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2 }, + { "_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__Open, 1 }, + { "_arrow_Table__from_RecordBatchFileReader", (DL_FUNC)& _arrow_Table__from_RecordBatchFileReader, 1 }, + { "_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC)& _arrow_Table__from_RecordBatchStreamReader, 1 }, + { "_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__batches, 1 }, + { "_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2 }, + { "_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteTable, 2 }, + { "_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__Close, 1 }, + { "_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileWriter__Open, 2 }, + { "_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamWriter__Open, 2 }, + { "_arrow_Table__from_dataframe", (DL_FUNC)& _arrow_Table__from_dataframe, 1 }, + { "_arrow_Table__num_columns", (DL_FUNC)& _arrow_Table__num_columns, 1 }, + { "_arrow_Table__num_rows", (DL_FUNC)& _arrow_Table__num_rows, 1 }, + { "_arrow_Table__schema", (DL_FUNC)& _arrow_Table__schema, 1 }, + { "_arrow_Table__column", (DL_FUNC)& _arrow_Table__column, 2 }, + { "_arrow_Table__columns", (DL_FUNC)& _arrow_Table__columns, 1 }, + { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_GetCpuThreadPoolCapacity, 0 }, + { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_SetCpuThreadPoolCapacity, 1 }, + {NULL, NULL, 0} +}; + +extern "C" void R_init_arrow(DllInfo* dll){ + R_registerRoutines(dll, NULL, arrow_CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} + diff --git a/r/src/io.cpp b/r/src/io.cpp index 82c2b20e333..cf142f302f8 100644 --- a/r/src/io.cpp +++ b/r/src/io.cpp @@ -19,9 +19,11 @@ using Rcpp::RawVector_; +#if defined(ARROW_R_WITH_ARROW) + // ------ arrow::io::Readable -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___Readable__Read( const std::shared_ptr& x, int64_t nbytes) { std::shared_ptr buf; @@ -31,21 +33,21 @@ std::shared_ptr io___Readable__Read( // ------ arrow::io::InputStream -// [[Rcpp::export]] +// [[arrow::export]] void io___InputStream__Close(const std::shared_ptr& x) { STOP_IF_NOT_OK(x->Close()); } // ------ arrow::io::OutputStream -// [[Rcpp::export]] +// [[arrow::export]] void io___OutputStream__Close(const std::shared_ptr& x) { STOP_IF_NOT_OK(x->Close()); } // ------ arrow::io::RandomAccessFile -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___RandomAccessFile__GetSize( const std::shared_ptr& x) { int64_t out; @@ -53,19 +55,19 @@ int64_t io___RandomAccessFile__GetSize( return out; } -// [[Rcpp::export]] +// [[arrow::export]] bool io___RandomAccessFile__supports_zero_copy( const std::shared_ptr& x) { return x->supports_zero_copy(); } -// [[Rcpp::export]] +// [[arrow::export]] void io___RandomAccessFile__Seek(const std::shared_ptr& x, int64_t position) { STOP_IF_NOT_OK(x->Seek(position)); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___RandomAccessFile__Tell( const std::shared_ptr& x) { int64_t out; @@ -75,7 +77,7 @@ int64_t io___RandomAccessFile__Tell( // ------ arrow::io::MemoryMappedFile -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___MemoryMappedFile__Create( const std::string& path, int64_t size) { std::shared_ptr out; @@ -83,7 +85,7 @@ std::shared_ptr io___MemoryMappedFile__Create( return out; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___MemoryMappedFile__Open( const std::string& path, arrow::io::FileMode::type mode) { std::shared_ptr out; @@ -91,7 +93,7 @@ std::shared_ptr io___MemoryMappedFile__Open( return out; } -// [[Rcpp::export]] +// [[arrow::export]] void io___MemoryMappedFile__Resize(const std::shared_ptr& x, int64_t size) { STOP_IF_NOT_OK(x->Resize(size)); @@ -99,7 +101,7 @@ void io___MemoryMappedFile__Resize(const std::shared_ptr io___ReadableFile__Open( const std::string& path) { std::shared_ptr out; @@ -109,7 +111,7 @@ std::shared_ptr io___ReadableFile__Open( // ------ arrow::io::BufferReader -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___BufferReader__initialize( const std::shared_ptr& buffer) { return std::make_shared(buffer); @@ -117,7 +119,7 @@ std::shared_ptr io___BufferReader__initialize( // ------- arrow::io::Writable -// [[Rcpp::export]] +// [[arrow::export]] void io___Writable__write(const std::shared_ptr& stream, const std::shared_ptr& buf) { STOP_IF_NOT_OK(stream->Write(buf->data(), buf->size())); @@ -125,7 +127,7 @@ void io___Writable__write(const std::shared_ptr& stream, // ------- arrow::io::OutputStream -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___OutputStream__Tell(const std::shared_ptr& stream) { int64_t position; STOP_IF_NOT_OK(stream->Tell(&position)); @@ -134,7 +136,7 @@ int64_t io___OutputStream__Tell(const std::shared_ptr& // ------ arrow::io::FileOutputStream -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___FileOutputStream__Open( const std::string& path) { std::shared_ptr stream; @@ -144,7 +146,7 @@ std::shared_ptr io___FileOutputStream__Open( // ------ arrow::BufferOutputStream -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___BufferOutputStream__Create( int64_t initial_capacity) { std::shared_ptr stream; @@ -153,13 +155,13 @@ std::shared_ptr io___BufferOutputStream__Create( return stream; } -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___BufferOutputStream__capacity( const std::shared_ptr& stream) { return stream->capacity(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___BufferOutputStream__Finish( const std::shared_ptr& stream) { std::shared_ptr buffer; @@ -167,7 +169,7 @@ std::shared_ptr io___BufferOutputStream__Finish( return buffer; } -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___BufferOutputStream__Tell( const std::shared_ptr& stream) { int64_t res; @@ -175,7 +177,7 @@ int64_t io___BufferOutputStream__Tell( return res; } -// [[Rcpp::export]] +// [[arrow::export]] void io___BufferOutputStream__Write( const std::shared_ptr& stream, RawVector_ bytes) { STOP_IF_NOT_OK(stream->Write(bytes.begin(), bytes.size())); @@ -183,12 +185,12 @@ void io___BufferOutputStream__Write( // ------ arrow::io::MockOutputStream -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___MockOutputStream__initialize() { return std::make_shared(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t io___MockOutputStream__GetExtentBytesWritten( const std::shared_ptr& stream) { return stream->GetExtentBytesWritten(); @@ -196,8 +198,10 @@ int64_t io___MockOutputStream__GetExtentBytesWritten( // ------ arrow::io::FixedSizeBufferWriter -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr io___FixedSizeBufferWriter__initialize( const std::shared_ptr& buffer) { return std::make_shared(buffer); } + +#endif diff --git a/r/src/memorypool.cpp b/r/src/memorypool.cpp index fa0bb4af84c..bd5cebf667e 100644 --- a/r/src/memorypool.cpp +++ b/r/src/memorypool.cpp @@ -16,19 +16,22 @@ // under the License. #include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr MemoryPool__default() { return std::shared_ptr(arrow::default_memory_pool(), NoDelete()); } -// [[Rcpp::export]] +// [[arrow::export]] int MemoryPool__bytes_allocated(const std::shared_ptr& pool) { return pool->bytes_allocated(); } -// [[Rcpp::export]] +// [[arrow::export]] int MemoryPool__max_memory(const std::shared_ptr& pool) { return pool->max_memory(); } + +#endif diff --git a/r/src/message.cpp b/r/src/message.cpp index cb8a3c97f57..2769458349d 100644 --- a/r/src/message.cpp +++ b/r/src/message.cpp @@ -17,41 +17,43 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] int64_t ipc___Message__body_length(const std::unique_ptr& message) { return message->body_length(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___Message__metadata( const std::unique_ptr& message) { return message->metadata(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___Message__body( const std::unique_ptr& message) { return message->body(); } -// [[Rcpp::export]] +// [[arrow::export]] int64_t ipc___Message__Verify(const std::unique_ptr& message) { return message->Verify(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::ipc::Message::Type ipc___Message__type( const std::unique_ptr& message) { return message->type(); } -// [[Rcpp::export]] +// [[arrow::export]] bool ipc___Message__Equals(const std::unique_ptr& x, const std::unique_ptr& y) { return x->Equals(*y); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___ReadRecordBatch__Message__Schema( const std::unique_ptr& message, const std::shared_ptr& schema) { @@ -63,7 +65,7 @@ std::shared_ptr ipc___ReadRecordBatch__Message__Schema( return batch; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___ReadSchema_InputStream( const std::shared_ptr& stream) { std::shared_ptr schema; @@ -75,13 +77,13 @@ std::shared_ptr ipc___ReadSchema_InputStream( //--------- MessageReader -// [[Rcpp::export]] +// [[arrow::export]] std::unique_ptr ipc___MessageReader__Open( const std::shared_ptr& stream) { return arrow::ipc::MessageReader::Open(stream); } -// [[Rcpp::export]] +// [[arrow::export]] std::unique_ptr ipc___MessageReader__ReadNextMessage( const std::unique_ptr& reader) { std::unique_ptr message; @@ -89,10 +91,12 @@ std::unique_ptr ipc___MessageReader__ReadNextMessage( return message; } -// [[Rcpp::export]] +// [[arrow::export]] std::unique_ptr ipc___ReadMessage( const std::shared_ptr& stream) { std::unique_ptr message; STOP_IF_NOT_OK(arrow::ipc::ReadMessage(stream.get(), &message)); return message; } + +#endif diff --git a/r/src/parquet.cpp b/r/src/parquet.cpp index 84264206a54..07d3d1d2beb 100644 --- a/r/src/parquet.cpp +++ b/r/src/parquet.cpp @@ -17,13 +17,16 @@ #include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) + #ifdef ARROW_R_WITH_PARQUET #include #include #include #endif -// [[Rcpp::export]] + +// [[arrow::export]] std::shared_ptr read_parquet_file(std::string filename) { #ifdef ARROW_R_WITH_PARQUET std::shared_ptr infile; @@ -44,3 +47,5 @@ std::shared_ptr read_parquet_file(std::string filename) { return table; #endif } + +#endif diff --git a/r/src/recordbatch.cpp b/r/src/recordbatch.cpp index 390143859f8..3d1b2803761 100644 --- a/r/src/recordbatch.cpp +++ b/r/src/recordbatch.cpp @@ -15,29 +15,30 @@ // specific language governing permissions and limitations // under the License. +#include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) #include #include #include #include -#include "./arrow_types.h" -// [[Rcpp::export]] +// [[arrow::export]] int RecordBatch__num_columns(const std::shared_ptr& x) { return x->num_columns(); } -// [[Rcpp::export]] +// [[arrow::export]] int RecordBatch__num_rows(const std::shared_ptr& x) { return x->num_rows(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__schema( const std::shared_ptr& x) { return x->schema(); } -// [[Rcpp::export]] +// [[arrow::export]] arrow::ArrayVector RecordBatch__columns( const std::shared_ptr& batch) { auto nc = batch->num_columns(); @@ -48,19 +49,41 @@ arrow::ArrayVector RecordBatch__columns( return res; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__column( const std::shared_ptr& batch, int i) { return batch->column(i); } +<<<<<<< HEAD // [[Rcpp::export]] +======= +// [[arrow::export]] +std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl) { + Rcpp::CharacterVector names = tbl.names(); + + std::vector> fields; + std::vector> arrays; + + for (int i = 0; i < tbl.size(); i++) { + SEXP x = tbl[i]; + arrays.push_back(Array__from_vector(x, R_NilValue)); + fields.push_back( + std::make_shared(std::string(names[i]), arrays[i]->type())); + } + auto schema = std::make_shared(std::move(fields)); + + return arrow::RecordBatch::Make(schema, tbl.nrow(), std::move(arrays)); +} + +// [[arrow::export]] +>>>>>>> Workaround so that the R package still checks without the C++ library. bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other) { return self->Equals(*other); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__RemoveColumn( const std::shared_ptr& batch, int i) { std::shared_ptr res; @@ -68,13 +91,13 @@ std::shared_ptr RecordBatch__RemoveColumn( return res; } -// [[Rcpp::export]] +// [[arrow::export]] std::string RecordBatch__column_name(const std::shared_ptr& batch, int i) { return batch->column_name(i); } -// [[Rcpp::export]] +// [[arrow::export]] Rcpp::CharacterVector RecordBatch__names( const std::shared_ptr& batch) { int n = batch->num_columns(); @@ -85,19 +108,19 @@ Rcpp::CharacterVector RecordBatch__names( return names; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__Slice1( const std::shared_ptr& self, int offset) { return self->Slice(offset); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__Slice2( const std::shared_ptr& self, int offset, int length) { return self->Slice(offset, length); } -// [[Rcpp::export]] +// [[arrow::export]] Rcpp::RawVector ipc___SerializeRecordBatch__Raw( const std::shared_ptr& batch) { // how many bytes do we need ? @@ -117,7 +140,7 @@ Rcpp::RawVector ipc___SerializeRecordBatch__Raw( return out; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___ReadRecordBatch__InputStream__Schema( const std::shared_ptr& stream, const std::shared_ptr& schema) { @@ -208,3 +231,5 @@ std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SE return arrow::RecordBatch::Make(schema, num_rows, arrays); } + +#endif diff --git a/r/src/recordbatchreader.cpp b/r/src/recordbatchreader.cpp index d88abe66ed2..42e2968fbc8 100644 --- a/r/src/recordbatchreader.cpp +++ b/r/src/recordbatchreader.cpp @@ -17,13 +17,15 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] std::shared_ptr RecordBatchReader__schema( const std::shared_ptr& reader) { return reader->schema(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatchReader__ReadNext( const std::shared_ptr& reader) { std::shared_ptr batch; @@ -33,7 +35,7 @@ std::shared_ptr RecordBatchReader__ReadNext( // -------- RecordBatchStreamReader -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchStreamReader__Open( const std::shared_ptr& stream) { std::shared_ptr reader; @@ -41,7 +43,7 @@ std::shared_ptr ipc___RecordBatchStreamReader__Open( return reader; } -// [[Rcpp::export]] +// [[arrow::export]] std::vector> ipc___RecordBatchStreamReader__batches( const std::shared_ptr& reader) { std::vector> res; @@ -59,19 +61,19 @@ std::vector> ipc___RecordBatchStreamReader__ // -------- RecordBatchFileReader -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchFileReader__schema( const std::shared_ptr& reader) { return reader->schema(); } -// [[Rcpp::export]] +// [[arrow::export]] int ipc___RecordBatchFileReader__num_record_batches( const std::shared_ptr& reader) { return reader->num_record_batches(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch( const std::shared_ptr& reader, int i) { std::shared_ptr batch; @@ -81,7 +83,7 @@ std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch return batch; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchFileReader__Open( const std::shared_ptr& file) { std::shared_ptr reader; @@ -89,7 +91,7 @@ std::shared_ptr ipc___RecordBatchFileReader__ return reader; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__from_RecordBatchFileReader( const std::shared_ptr& reader) { int num_batches = reader->num_record_batches(); @@ -104,7 +106,7 @@ std::shared_ptr Table__from_RecordBatchFileReader( return table; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__from_RecordBatchStreamReader( const std::shared_ptr& reader) { std::shared_ptr batch; @@ -121,7 +123,7 @@ std::shared_ptr Table__from_RecordBatchStreamReader( return table; } -// [[Rcpp::export]] +// [[arrow::export]] std::vector> ipc___RecordBatchFileReader__batches( const std::shared_ptr& reader) { auto n = reader->num_record_batches(); @@ -133,3 +135,5 @@ std::vector> ipc___RecordBatchFileReader__ba return res; } + +#endif diff --git a/r/src/recordbatchwriter.cpp b/r/src/recordbatchwriter.cpp index c4f0aca94d4..be5103f232f 100644 --- a/r/src/recordbatchwriter.cpp +++ b/r/src/recordbatchwriter.cpp @@ -17,27 +17,29 @@ #include "./arrow_types.h" -// [[Rcpp::export]] +#if defined(ARROW_R_WITH_ARROW) + +// [[arrow::export]] void ipc___RecordBatchWriter__WriteRecordBatch( const std::shared_ptr& batch_writer, const std::shared_ptr& batch) { STOP_IF_NOT_OK(batch_writer->WriteRecordBatch(*batch, true)); } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___RecordBatchWriter__WriteTable( const std::shared_ptr& batch_writer, const std::shared_ptr& table) { STOP_IF_NOT_OK(batch_writer->WriteTable(*table)); } -// [[Rcpp::export]] +// [[arrow::export]] void ipc___RecordBatchWriter__Close( const std::shared_ptr& batch_writer) { STOP_IF_NOT_OK(batch_writer->Close()); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchFileWriter__Open( const std::shared_ptr& stream, const std::shared_ptr& schema) { @@ -47,7 +49,7 @@ std::shared_ptr ipc___RecordBatchFileWriter__Open return file_writer; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr ipc___RecordBatchStreamWriter__Open( const std::shared_ptr& stream, const std::shared_ptr& schema) { @@ -56,3 +58,5 @@ std::shared_ptr ipc___RecordBatchStreamWriter__Op arrow::ipc::RecordBatchStreamWriter::Open(stream.get(), schema, &stream_writer)); return stream_writer; } + +#endif diff --git a/r/src/symbols.h b/r/src/symbols.h index 0c1317ad224..00dc997562a 100644 --- a/r/src/symbols.h +++ b/r/src/symbols.h @@ -15,6 +15,8 @@ // specific language governing permissions and limitations // under the License. +#pragma once + namespace arrow { namespace r { struct symbols { diff --git a/r/src/table.cpp b/r/src/table.cpp index f78b2afdd7a..52e6a4918c8 100644 --- a/r/src/table.cpp +++ b/r/src/table.cpp @@ -15,33 +15,45 @@ // specific language governing permissions and limitations // under the License. +#include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) + #include #include #include -#include "./arrow_types.h" using Rcpp::DataFrame; -// [[Rcpp::export]] +// [[arrow::export]] +std::shared_ptr Table__from_dataframe(DataFrame tbl) { + auto rb = RecordBatch__from_dataframe(tbl); + + std::shared_ptr out; + STOP_IF_NOT_OK(arrow::Table::FromRecordBatches({std::move(rb)}, &out)); + return out; +} + +// [[arrow::export]] +>>>>>>> Workaround so that the R package still checks without the C++ library. int Table__num_columns(const std::shared_ptr& x) { return x->num_columns(); } -// [[Rcpp::export]] +// [[arrow::export]] int Table__num_rows(const std::shared_ptr& x) { return x->num_rows(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__schema(const std::shared_ptr& x) { return x->schema(); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__column(const std::shared_ptr& table, int i) { return table->column(i); } -// [[Rcpp::export]] +// [[arrow::export]] std::vector> Table__columns( const std::shared_ptr& table) { auto nc = table->num_columns(); @@ -132,3 +144,5 @@ std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp) { return arrow::Table::Make(schema, columns); } + +#endif diff --git a/r/src/threadpool.cpp b/r/src/threadpool.cpp index 83fdb65bfbb..64f1246a873 100644 --- a/r/src/threadpool.cpp +++ b/r/src/threadpool.cpp @@ -15,11 +15,17 @@ // specific language governing permissions and limitations // under the License. -#include #include "./arrow_types.h" +#if defined(ARROW_R_WITH_ARROW) + +#include + + //' View and manage the capacity of the global thread pool //' +//' Get the capacity of the global thread pool +//' //' `GetCpuThreadPoolCapacity()` returns the number of worker threads in the //' thread pool to which //' Arrow dispatches various CPU-bound tasks. This is an ideal number, @@ -33,12 +39,14 @@ //' `SetCpuThreadPoolCapacity()` returns nothing. //' @export //' @name threadpool -// [[Rcpp::export]] +// [[arrow::export]] int GetCpuThreadPoolCapacity() { return arrow::GetCpuThreadPoolCapacity(); } //' @rdname threadpool //' @export -// [[Rcpp::export]] +// [[arrow::export]] void SetCpuThreadPoolCapacity(int threads) { STOP_IF_NOT_OK(arrow::SetCpuThreadPoolCapacity(threads)); } + +#endif diff --git a/r/tests/testthat.R b/r/tests/testthat.R index da5f1b1d720..e9627e61bb5 100644 --- a/r/tests/testthat.R +++ b/r/tests/testthat.R @@ -20,3 +20,4 @@ library(arrow) library(tibble) test_check("arrow") + diff --git a/r/tests/testthat/helper-arrow.R b/r/tests/testthat/helper-arrow.R new file mode 100644 index 00000000000..80dc495137b --- /dev/null +++ b/r/tests/testthat/helper-arrow.R @@ -0,0 +1,7 @@ + +test_that <- function(what, ...) { + testthat::test_that(what, { + skip_if(!arrow_available(), "arrow C++ library not available") + ... + }) +} diff --git a/r/tests/testthat/test-field.R b/r/tests/testthat/test-field.R index aaa2875510a..05f07c366d7 100644 --- a/r/tests/testthat/test-field.R +++ b/r/tests/testthat/test-field.R @@ -18,6 +18,8 @@ context("arrow::Field") test_that("field() factory", { + skip_if(!arrow_available(), "arrow C++ library not available") + x <- field("x", int32()) expect_equal(x$type, int32()) expect_equal(x$name, "x") From 1170236b7a4b88620c2a52e0d648f4fe1a41b047 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 13:27:12 +0200 Subject: [PATCH 03/24] not necessary --- r/tests/testthat/test-field.R | 2 -- 1 file changed, 2 deletions(-) diff --git a/r/tests/testthat/test-field.R b/r/tests/testthat/test-field.R index 05f07c366d7..aaa2875510a 100644 --- a/r/tests/testthat/test-field.R +++ b/r/tests/testthat/test-field.R @@ -18,8 +18,6 @@ context("arrow::Field") test_that("field() factory", { - skip_if(!arrow_available(), "arrow C++ library not available") - x <- field("x", int32()) expect_equal(x$type, int32()) expect_equal(x$name, "x") From f9575045f1d9e49a0e05b0aabc676c5790e9eaff Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 13:27:27 +0200 Subject: [PATCH 04/24] update test_that shim --- r/tests/testthat/helper-arrow.R | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/r/tests/testthat/helper-arrow.R b/r/tests/testthat/helper-arrow.R index 80dc495137b..875fbab2b66 100644 --- a/r/tests/testthat/helper-arrow.R +++ b/r/tests/testthat/helper-arrow.R @@ -1,7 +1,7 @@ -test_that <- function(what, ...) { +test_that <- function(what, code) { testthat::test_that(what, { skip_if(!arrow_available(), "arrow C++ library not available") - ... + code }) } From 008eaf4a5256dc448abe77eceeae180bf2e8d901 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 13:28:11 +0200 Subject: [PATCH 05/24] update generated code, fix merge conflicts --- r/R/generated.R | 12 ++- r/man/table.Rd | 5 +- r/man/threadpool.Rd | 27 ------ r/src/Rcpp_arrow_definitions.h | 66 -------------- r/src/Rcpp_arrow_forward.h | 98 --------------------- r/src/arrow_types.h | 151 ++++++++++++++++++++++++++++++++- r/src/datatype.cpp | 14 +-- r/src/generated.cpp | 36 ++++++++ r/src/recordbatch.cpp | 7 +- r/src/table.cpp | 5 +- 10 files changed, 203 insertions(+), 218 deletions(-) delete mode 100644 r/man/threadpool.Rd delete mode 100644 r/src/Rcpp_arrow_definitions.h delete mode 100644 r/src/Rcpp_arrow_forward.h diff --git a/r/R/generated.R b/r/R/generated.R index 1fa537ef5a9..0b824fc9744 100644 --- a/r/R/generated.R +++ b/r/R/generated.R @@ -728,6 +728,10 @@ ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema) { .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema` , stream, schema ) } +RecordBatch__from_arrays <- function(schema_sxp, lst) { + .Call(`_arrow_RecordBatch__from_arrays` , schema_sxp, lst ) +} + RecordBatchReader__schema <- function(reader) { .Call(`_arrow_RecordBatchReader__schema` , reader ) } @@ -816,6 +820,10 @@ Table__columns <- function(table) { .Call(`_arrow_Table__columns` , table ) } +Table__from_dots <- function(lst, schema_sxp) { + .Call(`_arrow_Table__from_dots` , lst, schema_sxp ) +} + GetCpuThreadPoolCapacity <- function() { .Call(`_arrow_GetCpuThreadPoolCapacity` ) } @@ -825,7 +833,3 @@ SetCpuThreadPoolCapacity <- function(threads) { } -arrow_available <- function() { - .Call(`_arrow_available`) -} - diff --git a/r/man/table.Rd b/r/man/table.Rd index 4d93ff385b5..fbf9632a03a 100644 --- a/r/man/table.Rd +++ b/r/man/table.Rd @@ -9,7 +9,10 @@ table(..., schema = NULL) \arguments{ \item{...}{arrays, chunked arrays, or R vectors} -\item{schema}{NULL or a schema} +\item{schema}{a schema. The default (\code{NULL}) infers the schema from the \code{...}} +} +\value{ +an arrow::Table } \description{ Create an arrow::Table from a data frame diff --git a/r/man/threadpool.Rd b/r/man/threadpool.Rd deleted file mode 100644 index 9cf162f573a..00000000000 --- a/r/man/threadpool.Rd +++ /dev/null @@ -1,27 +0,0 @@ -% Generated by roxygen2: do not edit by hand -% Please edit documentation in R/RcppExports.R -\name{threadpool} -\alias{threadpool} -\alias{GetCpuThreadPoolCapacity} -\alias{SetCpuThreadPoolCapacity} -\title{View and manage the capacity of the global thread pool} -\usage{ -GetCpuThreadPoolCapacity() - -SetCpuThreadPoolCapacity(threads) -} -\arguments{ -\item{threads}{the number of worker threads in the thread pool to which -Arrow dispatches various CPU-bound tasks.} -} -\value{ -\code{GetCpuThreadPoolCapacity()} returns the number of worker threads. -\code{SetCpuThreadPoolCapacity()} returns nothing. -} -\description{ -\code{GetCpuThreadPoolCapacity()} returns the number of worker threads in the -thread pool to which -Arrow dispatches various CPU-bound tasks. This is an ideal number, -not necessarily the exact number of threads at a given point in time. -You can change this number using \code{SetCpuThreadPoolCapacity()}. -} diff --git a/r/src/Rcpp_arrow_definitions.h b/r/src/Rcpp_arrow_definitions.h deleted file mode 100644 index 0be44024a38..00000000000 --- a/r/src/Rcpp_arrow_definitions.h +++ /dev/null @@ -1,66 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -namespace Rcpp { -namespace internal { - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag) { - return Rcpp::XPtr>( - new std::shared_ptr(x)); -} - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag) { - return Rcpp::XPtr>( - new std::unique_ptr(const_cast(x).release())); -} - -} // namespace internal - -} // namespace Rcpp - -namespace Rcpp { -using NumericVector_ = Rcpp::Vector; -using IntegerVector_ = Rcpp::Vector; -using LogicalVector_ = Rcpp::Vector; -using StringVector_ = Rcpp::Vector; -using CharacterVector_ = StringVector_; -using RawVector_ = Rcpp::Vector; -using List_ = Rcpp::Vector; - -template -inline constexpr typename Rcpp::Vector::stored_type default_value() { - return Rcpp::Vector::get_na(); -} -template <> -inline constexpr Rbyte default_value() { - return 0; -} - -} // namespace Rcpp - -namespace arrow { -namespace r { - -template -inline std::shared_ptr extract(SEXP x) { - return Rcpp::ConstReferenceSmartPtrInputParameter>(x); -} - -} // namespace r -} // namespace arrow diff --git a/r/src/Rcpp_arrow_forward.h b/r/src/Rcpp_arrow_forward.h deleted file mode 100644 index 295eccc280f..00000000000 --- a/r/src/Rcpp_arrow_forward.h +++ /dev/null @@ -1,98 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "./symbols.h" - -#define STOP_IF_NOT(TEST, MSG) \ -do { \ - if (!(TEST)) Rcpp::stop(MSG); \ -} while (0) - -#define STOP_IF_NOT_OK(s) STOP_IF_NOT(s.ok(), s.ToString()) - -template -inline void STOP_IF_NULL(T* ptr) { - STOP_IF_NOT(ptr, "invalid data"); -} - -template -struct NoDelete { - inline void operator()(T* ptr) {} -}; - -namespace Rcpp { -namespace internal { - -template -Pointer r6_to_smart_pointer(SEXP self) { - return reinterpret_cast( - EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); -} - -} // namespace internal - -template -class ConstReferenceSmartPtrInputParameter { -public: - using const_reference = const T&; - - explicit ConstReferenceSmartPtrInputParameter(SEXP self) - : ptr(internal::r6_to_smart_pointer(self)) {} - - inline operator const_reference() { return *ptr; } - -private: - const T* ptr; -}; - -namespace traits { - -template -struct input_parameter&> { - typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; -}; - -template -struct input_parameter&> { - typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; -}; - -struct wrap_type_shared_ptr_tag {}; -struct wrap_type_unique_ptr_tag {}; - -template -struct wrap_type_traits> { - using wrap_category = wrap_type_shared_ptr_tag; -}; - -template -struct wrap_type_traits> { - using wrap_category = wrap_type_unique_ptr_tag; -}; - -} // namespace traits - -namespace internal { - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag); - -template -inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag); - -} // namespace internal -} // namespace Rcpp diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h index 51ffdef4b8b..93dae81961a 100644 --- a/r/src/arrow_types.h +++ b/r/src/arrow_types.h @@ -25,9 +25,140 @@ #undef Free #include "./symbols.h" -#include "./Rcpp_arrow_forward.h" + +#define STOP_IF_NOT(TEST, MSG) \ +do { \ + if (!(TEST)) Rcpp::stop(MSG); \ +} while (0) + +#define STOP_IF_NOT_OK(s) STOP_IF_NOT(s.ok(), s.ToString()) + +template +inline void STOP_IF_NULL(T* ptr) { + STOP_IF_NOT(ptr, "invalid data"); +} + +template +struct NoDelete { + inline void operator()(T* ptr) {} +}; + +namespace Rcpp { +namespace internal { + +template +Pointer r6_to_smart_pointer(SEXP self) { + return reinterpret_cast( + EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); +} + +} // namespace internal + +template +class ConstReferenceSmartPtrInputParameter { +public: + using const_reference = const T&; + + explicit ConstReferenceSmartPtrInputParameter(SEXP self) + : ptr(internal::r6_to_smart_pointer(self)) {} + + inline operator const_reference() { return *ptr; } + +private: + const T* ptr; +}; + +namespace traits { + +template +struct input_parameter&> { + typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; +}; + +template +struct input_parameter&> { + typedef typename Rcpp::ConstReferenceSmartPtrInputParameter> type; +}; + +struct wrap_type_shared_ptr_tag {}; +struct wrap_type_unique_ptr_tag {}; + +template +struct wrap_type_traits> { + using wrap_category = wrap_type_shared_ptr_tag; +}; + +template +struct wrap_type_traits> { + using wrap_category = wrap_type_unique_ptr_tag; +}; + +} // namespace traits + +namespace internal { + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag); + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag); + +} // namespace internal +} // namespace Rcpp + #include -#include "./Rcpp_arrow_definitions.h" + +namespace Rcpp { +namespace internal { + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_shared_ptr_tag) { + return Rcpp::XPtr>( + new std::shared_ptr(x)); +} + +template +inline SEXP wrap_dispatch(const T& x, Rcpp::traits::wrap_type_unique_ptr_tag) { + return Rcpp::XPtr>( + new std::unique_ptr(const_cast(x).release())); +} + +} // namespace internal + +} // namespace Rcpp + +namespace Rcpp { +using NumericVector_ = Rcpp::Vector; +using IntegerVector_ = Rcpp::Vector; +using LogicalVector_ = Rcpp::Vector; +using StringVector_ = Rcpp::Vector; +using CharacterVector_ = StringVector_; +using RawVector_ = Rcpp::Vector; +using List_ = Rcpp::Vector; + +template +inline constexpr typename Rcpp::Vector::stored_type default_value() { + return Rcpp::Vector::get_na(); +} +template <> +inline constexpr Rbyte default_value() { + return 0; +} + +} // namespace Rcpp + +namespace arrow { +namespace r { + +template +inline std::shared_ptr extract(SEXP x) { + return Rcpp::ConstReferenceSmartPtrInputParameter>(x); +} + +} // namespace r +} // namespace arrow + + #if defined(ARROW_R_WITH_ARROW) #include @@ -54,10 +185,26 @@ SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked SEXP Array__as_vector(const std::shared_ptr& array); std::shared_ptr Array__from_vector(SEXP x, SEXP type); std::shared_ptr RecordBatch__from_arrays(SEXP, SEXP); +std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl); namespace arrow { namespace r { +std::shared_ptr Array__from_vector( + SEXP x, const std::shared_ptr& type, bool type_infered +); + +template +std::vector> List_to_shared_ptr_vector(SEXP x) { + std::vector> vec; + R_xlen_t n = Rf_xlength(x); + for (R_xlen_t i=0; i < n; i++) { + Rcpp::ConstReferenceSmartPtrInputParameter> ptr(VECTOR_ELT(x, i)); + vec.push_back(ptr); + } + return vec; +} + void inspect(SEXP obj); // the integer64 sentinel diff --git a/r/src/datatype.cpp b/r/src/datatype.cpp index 1447553a25b..0ab881dd6c6 100644 --- a/r/src/datatype.cpp +++ b/r/src/datatype.cpp @@ -130,19 +130,9 @@ SEXP list__(SEXP x) { return R_NilValue; } -template -std::vector> List_to_shared_ptr_vector(List x) { - std::vector> vec; - for (SEXP element : x) { - Rcpp::ConstReferenceSmartPtrInputParameter> ptr(element); - vec.push_back(ptr); - } - return vec; -} - // [[arrow::export]] std::shared_ptr struct_(List fields) { - return arrow::struct_(List_to_shared_ptr_vector(fields)); + return arrow::struct_(arrow::r::List_to_shared_ptr_vector(fields)); } // [[arrow::export]] @@ -178,7 +168,7 @@ arrow::Type::type DataType__id(const std::shared_ptr& type) { // [[arrow::export]] std::shared_ptr schema_(List fields) { - return arrow::schema(List_to_shared_ptr_vector(fields)); + return arrow::schema(arrow::r::List_to_shared_ptr_vector(fields)); } // [[arrow::export]] diff --git a/r/src/generated.cpp b/r/src/generated.cpp index 998f3f97a88..429135bde9e 100644 --- a/r/src/generated.cpp +++ b/r/src/generated.cpp @@ -2984,6 +2984,23 @@ SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP sc } #endif +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst); +SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); +Rcpp::traits::input_parameter::type lst(lst_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__from_arrays( schema_sxp, lst))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatchReader__schema(const std::shared_ptr& reader); SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ @@ -3342,6 +3359,23 @@ SEXP _arrow_Table__columns(SEXP table_sexp){ } #endif +#if defined(ARROW_R_WITH_ARROW) +std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp); +SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ + BEGIN_RCPP + Rcpp::traits::input_parameter::type lst(lst_sexp); +Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_dots( lst, schema_sxp))); +return rcpp_result_gen; + END_RCPP +} +#else +SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ + BEGIN_RCPP + Rcpp::stop("arrow C++ library not available"); + END_RCPP +} +#endif + #if defined(ARROW_R_WITH_ARROW) int GetCpuThreadPoolCapacity(); SEXP _arrow_GetCpuThreadPoolCapacity(){ @@ -3569,6 +3603,7 @@ static const R_CallMethodDef arrow_CallEntries[] = { { "_arrow_RecordBatch__Slice2", (DL_FUNC)& _arrow_RecordBatch__Slice2, 3 }, { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC)& _arrow_ipc___SerializeRecordBatch__Raw, 1 }, { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__InputStream__Schema, 2 }, + { "_arrow_RecordBatch__from_arrays", (DL_FUNC)& _arrow_RecordBatch__from_arrays, 2 }, { "_arrow_RecordBatchReader__schema", (DL_FUNC)& _arrow_RecordBatchReader__schema, 1 }, { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC)& _arrow_RecordBatchReader__ReadNext, 1 }, { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__Open, 1 }, @@ -3591,6 +3626,7 @@ static const R_CallMethodDef arrow_CallEntries[] = { { "_arrow_Table__schema", (DL_FUNC)& _arrow_Table__schema, 1 }, { "_arrow_Table__column", (DL_FUNC)& _arrow_Table__column, 2 }, { "_arrow_Table__columns", (DL_FUNC)& _arrow_Table__columns, 1 }, + { "_arrow_Table__from_dots", (DL_FUNC)& _arrow_Table__from_dots, 2 }, { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_GetCpuThreadPoolCapacity, 0 }, { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_SetCpuThreadPoolCapacity, 1 }, {NULL, NULL, 0} diff --git a/r/src/recordbatch.cpp b/r/src/recordbatch.cpp index 3d1b2803761..03d749f7eba 100644 --- a/r/src/recordbatch.cpp +++ b/r/src/recordbatch.cpp @@ -16,6 +16,7 @@ // under the License. #include "./arrow_types.h" + #if defined(ARROW_R_WITH_ARROW) #include #include @@ -55,9 +56,6 @@ std::shared_ptr RecordBatch__column( return batch->column(i); } -<<<<<<< HEAD -// [[Rcpp::export]] -======= // [[arrow::export]] std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl) { Rcpp::CharacterVector names = tbl.names(); @@ -77,7 +75,6 @@ std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame } // [[arrow::export]] ->>>>>>> Workaround so that the R package still checks without the C++ library. bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other) { return self->Equals(*other); @@ -189,7 +186,7 @@ std::shared_ptr RecordBatch__from_arrays__known_schema( return arrow::RecordBatch::Make(schema, num_rows, arrays); } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst) { if (Rf_inherits(schema_sxp, "arrow::Schema")) { return RecordBatch__from_arrays__known_schema( diff --git a/r/src/table.cpp b/r/src/table.cpp index 52e6a4918c8..b181c1c8445 100644 --- a/r/src/table.cpp +++ b/r/src/table.cpp @@ -34,7 +34,6 @@ std::shared_ptr Table__from_dataframe(DataFrame tbl) { } // [[arrow::export]] ->>>>>>> Workaround so that the R package still checks without the C++ library. int Table__num_columns(const std::shared_ptr& x) { return x->num_columns(); } @@ -72,13 +71,13 @@ bool all_record_batches(SEXP lst) { return true; } -// [[Rcpp::export]] +// [[arrow::export]] std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp) { // lst can be either: // - a list of record batches, in which case we call Table::FromRecordBatches if (all_record_batches(lst)) { - auto batches = arrow::r::list_to_shared_ptr_vector(lst); + auto batches = arrow::r::List_to_shared_ptr_vector(lst); std::shared_ptr tab; if (Rf_inherits(schema_sxp, "arrow::Schema")) { From 0479a7537cfbbf03993a07e8eb4f818af1d7da70 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 15:20:38 +0200 Subject: [PATCH 06/24] code generation without rap package, using purrr instead --- r/R/generated.R | 832 +++++------ r/data-raw/codegen.R | 178 ++- r/src/generated.cpp | 3269 ++++++++++++++++++++---------------------- 3 files changed, 2025 insertions(+), 2254 deletions(-) diff --git a/r/R/generated.R b/r/R/generated.R index 0b824fc9744..6359f9057f9 100644 --- a/r/R/generated.R +++ b/r/R/generated.R @@ -1,835 +1,835 @@ # Generated by using data-raw/codegen.R -> do not edit by hand -Array__Slice1 <- function(array, offset) { - .Call(`_arrow_Array__Slice1` , array, offset ) +Array__Slice1 <- function(array, offset){ + .Call(`_arrow_Array__Slice1` , array, offset) } -Array__Slice2 <- function(array, offset, length) { - .Call(`_arrow_Array__Slice2` , array, offset, length ) +Array__Slice2 <- function(array, offset, length){ + .Call(`_arrow_Array__Slice2` , array, offset, length) } -Array__IsNull <- function(x, i) { - .Call(`_arrow_Array__IsNull` , x, i ) +Array__IsNull <- function(x, i){ + .Call(`_arrow_Array__IsNull` , x, i) } -Array__IsValid <- function(x, i) { - .Call(`_arrow_Array__IsValid` , x, i ) +Array__IsValid <- function(x, i){ + .Call(`_arrow_Array__IsValid` , x, i) } -Array__length <- function(x) { - .Call(`_arrow_Array__length` , x ) +Array__length <- function(x){ + .Call(`_arrow_Array__length` , x) } -Array__offset <- function(x) { - .Call(`_arrow_Array__offset` , x ) +Array__offset <- function(x){ + .Call(`_arrow_Array__offset` , x) } -Array__null_count <- function(x) { - .Call(`_arrow_Array__null_count` , x ) +Array__null_count <- function(x){ + .Call(`_arrow_Array__null_count` , x) } -Array__type <- function(x) { - .Call(`_arrow_Array__type` , x ) +Array__type <- function(x){ + .Call(`_arrow_Array__type` , x) } -Array__ToString <- function(x) { - .Call(`_arrow_Array__ToString` , x ) +Array__ToString <- function(x){ + .Call(`_arrow_Array__ToString` , x) } -Array__type_id <- function(x) { - .Call(`_arrow_Array__type_id` , x ) +Array__type_id <- function(x){ + .Call(`_arrow_Array__type_id` , x) } -Array__Equals <- function(lhs, rhs) { - .Call(`_arrow_Array__Equals` , lhs, rhs ) +Array__Equals <- function(lhs, rhs){ + .Call(`_arrow_Array__Equals` , lhs, rhs) } -Array__ApproxEquals <- function(lhs, rhs) { - .Call(`_arrow_Array__ApproxEquals` , lhs, rhs ) +Array__ApproxEquals <- function(lhs, rhs){ + .Call(`_arrow_Array__ApproxEquals` , lhs, rhs) } -Array__data <- function(array) { - .Call(`_arrow_Array__data` , array ) +Array__data <- function(array){ + .Call(`_arrow_Array__data` , array) } -Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx) { - .Call(`_arrow_Array__RangeEquals` , self, other, start_idx, end_idx, other_start_idx ) +Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx){ + .Call(`_arrow_Array__RangeEquals` , self, other, start_idx, end_idx, other_start_idx) } -Array__Mask <- function(array) { - .Call(`_arrow_Array__Mask` , array ) +Array__Mask <- function(array){ + .Call(`_arrow_Array__Mask` , array) } -DictionaryArray__indices <- function(array) { - .Call(`_arrow_DictionaryArray__indices` , array ) +DictionaryArray__indices <- function(array){ + .Call(`_arrow_DictionaryArray__indices` , array) } -DictionaryArray__dictionary <- function(array) { - .Call(`_arrow_DictionaryArray__dictionary` , array ) +DictionaryArray__dictionary <- function(array){ + .Call(`_arrow_DictionaryArray__dictionary` , array) } -Array__as_vector <- function(array) { - .Call(`_arrow_Array__as_vector` , array ) +Array__as_vector <- function(array){ + .Call(`_arrow_Array__as_vector` , array) } -ChunkedArray__as_vector <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__as_vector` , chunked_array ) +ChunkedArray__as_vector <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__as_vector` , chunked_array) } -RecordBatch__to_dataframe <- function(batch, use_threads) { - .Call(`_arrow_RecordBatch__to_dataframe` , batch, use_threads ) +RecordBatch__to_dataframe <- function(batch, use_threads){ + .Call(`_arrow_RecordBatch__to_dataframe` , batch, use_threads) } -Table__to_dataframe <- function(table, use_threads) { - .Call(`_arrow_Table__to_dataframe` , table, use_threads ) +Table__to_dataframe <- function(table, use_threads){ + .Call(`_arrow_Table__to_dataframe` , table, use_threads) } -Array__infer_type <- function(x) { - .Call(`_arrow_Array__infer_type` , x ) +Array__infer_type <- function(x){ + .Call(`_arrow_Array__infer_type` , x) } -Array__from_vector <- function(x, s_type) { - .Call(`_arrow_Array__from_vector` , x, s_type ) +Array__from_vector <- function(x, s_type){ + .Call(`_arrow_Array__from_vector` , x, s_type) } -ChunkedArray__from_list <- function(chunks, s_type) { - .Call(`_arrow_ChunkedArray__from_list` , chunks, s_type ) +ChunkedArray__from_list <- function(chunks, s_type){ + .Call(`_arrow_ChunkedArray__from_list` , chunks, s_type) } -ArrayData__get_type <- function(x) { - .Call(`_arrow_ArrayData__get_type` , x ) +ArrayData__get_type <- function(x){ + .Call(`_arrow_ArrayData__get_type` , x) } -ArrayData__get_length <- function(x) { - .Call(`_arrow_ArrayData__get_length` , x ) +ArrayData__get_length <- function(x){ + .Call(`_arrow_ArrayData__get_length` , x) } -ArrayData__get_null_count <- function(x) { - .Call(`_arrow_ArrayData__get_null_count` , x ) +ArrayData__get_null_count <- function(x){ + .Call(`_arrow_ArrayData__get_null_count` , x) } -ArrayData__get_offset <- function(x) { - .Call(`_arrow_ArrayData__get_offset` , x ) +ArrayData__get_offset <- function(x){ + .Call(`_arrow_ArrayData__get_offset` , x) } -ArrayData__buffers <- function(x) { - .Call(`_arrow_ArrayData__buffers` , x ) +ArrayData__buffers <- function(x){ + .Call(`_arrow_ArrayData__buffers` , x) } -Buffer__is_mutable <- function(buffer) { - .Call(`_arrow_Buffer__is_mutable` , buffer ) +Buffer__is_mutable <- function(buffer){ + .Call(`_arrow_Buffer__is_mutable` , buffer) } -Buffer__ZeroPadding <- function(buffer) { - invisible(.Call(`_arrow_Buffer__ZeroPadding` , buffer )) +Buffer__ZeroPadding <- function(buffer){ + invisible(.Call(`_arrow_Buffer__ZeroPadding` , buffer)) } -Buffer__capacity <- function(buffer) { - .Call(`_arrow_Buffer__capacity` , buffer ) +Buffer__capacity <- function(buffer){ + .Call(`_arrow_Buffer__capacity` , buffer) } -Buffer__size <- function(buffer) { - .Call(`_arrow_Buffer__size` , buffer ) +Buffer__size <- function(buffer){ + .Call(`_arrow_Buffer__size` , buffer) } -r___RBuffer__initialize <- function(x) { - .Call(`_arrow_r___RBuffer__initialize` , x ) +r___RBuffer__initialize <- function(x){ + .Call(`_arrow_r___RBuffer__initialize` , x) } -ChunkedArray__length <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__length` , chunked_array ) +ChunkedArray__length <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__length` , chunked_array) } -ChunkedArray__null_count <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__null_count` , chunked_array ) +ChunkedArray__null_count <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__null_count` , chunked_array) } -ChunkedArray__num_chunks <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__num_chunks` , chunked_array ) +ChunkedArray__num_chunks <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__num_chunks` , chunked_array) } -ChunkedArray__chunk <- function(chunked_array, i) { - .Call(`_arrow_ChunkedArray__chunk` , chunked_array, i ) +ChunkedArray__chunk <- function(chunked_array, i){ + .Call(`_arrow_ChunkedArray__chunk` , chunked_array, i) } -ChunkedArray__chunks <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__chunks` , chunked_array ) +ChunkedArray__chunks <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__chunks` , chunked_array) } -ChunkedArray__type <- function(chunked_array) { - .Call(`_arrow_ChunkedArray__type` , chunked_array ) +ChunkedArray__type <- function(chunked_array){ + .Call(`_arrow_ChunkedArray__type` , chunked_array) } -ChunkArray__Slice1 <- function(chunked_array, offset) { - .Call(`_arrow_ChunkArray__Slice1` , chunked_array, offset ) +ChunkArray__Slice1 <- function(chunked_array, offset){ + .Call(`_arrow_ChunkArray__Slice1` , chunked_array, offset) } -ChunkArray__Slice2 <- function(chunked_array, offset, length) { - .Call(`_arrow_ChunkArray__Slice2` , chunked_array, offset, length ) +ChunkArray__Slice2 <- function(chunked_array, offset, length){ + .Call(`_arrow_ChunkArray__Slice2` , chunked_array, offset, length) } -Column__length <- function(column) { - .Call(`_arrow_Column__length` , column ) +Column__length <- function(column){ + .Call(`_arrow_Column__length` , column) } -Column__null_count <- function(column) { - .Call(`_arrow_Column__null_count` , column ) +Column__null_count <- function(column){ + .Call(`_arrow_Column__null_count` , column) } -Column__type <- function(column) { - .Call(`_arrow_Column__type` , column ) +Column__type <- function(column){ + .Call(`_arrow_Column__type` , column) } -Column__data <- function(column) { - .Call(`_arrow_Column__data` , column ) +Column__data <- function(column){ + .Call(`_arrow_Column__data` , column) } -util___Codec__Create <- function(codec) { - .Call(`_arrow_util___Codec__Create` , codec ) +util___Codec__Create <- function(codec){ + .Call(`_arrow_util___Codec__Create` , codec) } -io___CompressedOutputStream__Make <- function(codec, raw) { - .Call(`_arrow_io___CompressedOutputStream__Make` , codec, raw ) +io___CompressedOutputStream__Make <- function(codec, raw){ + .Call(`_arrow_io___CompressedOutputStream__Make` , codec, raw) } -io___CompressedInputStream__Make <- function(codec, raw) { - .Call(`_arrow_io___CompressedInputStream__Make` , codec, raw ) +io___CompressedInputStream__Make <- function(codec, raw){ + .Call(`_arrow_io___CompressedInputStream__Make` , codec, raw) } -compute___CastOptions__initialize <- function(allow_int_overflow, allow_time_truncate, allow_float_truncate) { - .Call(`_arrow_compute___CastOptions__initialize` , allow_int_overflow, allow_time_truncate, allow_float_truncate ) +compute___CastOptions__initialize <- function(allow_int_overflow, allow_time_truncate, allow_float_truncate){ + .Call(`_arrow_compute___CastOptions__initialize` , allow_int_overflow, allow_time_truncate, allow_float_truncate) } -Array__cast <- function(array, target_type, options) { - .Call(`_arrow_Array__cast` , array, target_type, options ) +Array__cast <- function(array, target_type, options){ + .Call(`_arrow_Array__cast` , array, target_type, options) } -ChunkedArray__cast <- function(chunked_array, target_type, options) { - .Call(`_arrow_ChunkedArray__cast` , chunked_array, target_type, options ) +ChunkedArray__cast <- function(chunked_array, target_type, options){ + .Call(`_arrow_ChunkedArray__cast` , chunked_array, target_type, options) } -RecordBatch__cast <- function(batch, schema, options) { - .Call(`_arrow_RecordBatch__cast` , batch, schema, options ) +RecordBatch__cast <- function(batch, schema, options){ + .Call(`_arrow_RecordBatch__cast` , batch, schema, options) } -Table__cast <- function(table, schema, options) { - .Call(`_arrow_Table__cast` , table, schema, options ) +Table__cast <- function(table, schema, options){ + .Call(`_arrow_Table__cast` , table, schema, options) } -csv___ReadOptions__initialize <- function(options) { - .Call(`_arrow_csv___ReadOptions__initialize` , options ) +csv___ReadOptions__initialize <- function(options){ + .Call(`_arrow_csv___ReadOptions__initialize` , options) } -csv___ParseOptions__initialize <- function(options) { - .Call(`_arrow_csv___ParseOptions__initialize` , options ) +csv___ParseOptions__initialize <- function(options){ + .Call(`_arrow_csv___ParseOptions__initialize` , options) } -csv___ConvertOptions__initialize <- function(options) { - .Call(`_arrow_csv___ConvertOptions__initialize` , options ) +csv___ConvertOptions__initialize <- function(options){ + .Call(`_arrow_csv___ConvertOptions__initialize` , options) } -csv___TableReader__Make <- function(input, read_options, parse_options, convert_options) { - .Call(`_arrow_csv___TableReader__Make` , input, read_options, parse_options, convert_options ) +csv___TableReader__Make <- function(input, read_options, parse_options, convert_options){ + .Call(`_arrow_csv___TableReader__Make` , input, read_options, parse_options, convert_options) } -csv___TableReader__Read <- function(table_reader) { - .Call(`_arrow_csv___TableReader__Read` , table_reader ) +csv___TableReader__Read <- function(table_reader){ + .Call(`_arrow_csv___TableReader__Read` , table_reader) } -shared_ptr_is_null <- function(xp) { - .Call(`_arrow_shared_ptr_is_null` , xp ) +shared_ptr_is_null <- function(xp){ + .Call(`_arrow_shared_ptr_is_null` , xp) } -unique_ptr_is_null <- function(xp) { - .Call(`_arrow_unique_ptr_is_null` , xp ) +unique_ptr_is_null <- function(xp){ + .Call(`_arrow_unique_ptr_is_null` , xp) } -Int8__initialize <- function() { - .Call(`_arrow_Int8__initialize` ) +Int8__initialize <- function(){ + .Call(`_arrow_Int8__initialize` ) } -Int16__initialize <- function() { - .Call(`_arrow_Int16__initialize` ) +Int16__initialize <- function(){ + .Call(`_arrow_Int16__initialize` ) } -Int32__initialize <- function() { - .Call(`_arrow_Int32__initialize` ) +Int32__initialize <- function(){ + .Call(`_arrow_Int32__initialize` ) } -Int64__initialize <- function() { - .Call(`_arrow_Int64__initialize` ) +Int64__initialize <- function(){ + .Call(`_arrow_Int64__initialize` ) } -UInt8__initialize <- function() { - .Call(`_arrow_UInt8__initialize` ) +UInt8__initialize <- function(){ + .Call(`_arrow_UInt8__initialize` ) } -UInt16__initialize <- function() { - .Call(`_arrow_UInt16__initialize` ) +UInt16__initialize <- function(){ + .Call(`_arrow_UInt16__initialize` ) } -UInt32__initialize <- function() { - .Call(`_arrow_UInt32__initialize` ) +UInt32__initialize <- function(){ + .Call(`_arrow_UInt32__initialize` ) } -UInt64__initialize <- function() { - .Call(`_arrow_UInt64__initialize` ) +UInt64__initialize <- function(){ + .Call(`_arrow_UInt64__initialize` ) } -Float16__initialize <- function() { - .Call(`_arrow_Float16__initialize` ) +Float16__initialize <- function(){ + .Call(`_arrow_Float16__initialize` ) } -Float32__initialize <- function() { - .Call(`_arrow_Float32__initialize` ) +Float32__initialize <- function(){ + .Call(`_arrow_Float32__initialize` ) } -Float64__initialize <- function() { - .Call(`_arrow_Float64__initialize` ) +Float64__initialize <- function(){ + .Call(`_arrow_Float64__initialize` ) } -Boolean__initialize <- function() { - .Call(`_arrow_Boolean__initialize` ) +Boolean__initialize <- function(){ + .Call(`_arrow_Boolean__initialize` ) } -Utf8__initialize <- function() { - .Call(`_arrow_Utf8__initialize` ) +Utf8__initialize <- function(){ + .Call(`_arrow_Utf8__initialize` ) } -Date32__initialize <- function() { - .Call(`_arrow_Date32__initialize` ) +Date32__initialize <- function(){ + .Call(`_arrow_Date32__initialize` ) } -Date64__initialize <- function() { - .Call(`_arrow_Date64__initialize` ) +Date64__initialize <- function(){ + .Call(`_arrow_Date64__initialize` ) } -Null__initialize <- function() { - .Call(`_arrow_Null__initialize` ) +Null__initialize <- function(){ + .Call(`_arrow_Null__initialize` ) } -Decimal128Type__initialize <- function(precision, scale) { - .Call(`_arrow_Decimal128Type__initialize` , precision, scale ) +Decimal128Type__initialize <- function(precision, scale){ + .Call(`_arrow_Decimal128Type__initialize` , precision, scale) } -FixedSizeBinary__initialize <- function(byte_width) { - .Call(`_arrow_FixedSizeBinary__initialize` , byte_width ) +FixedSizeBinary__initialize <- function(byte_width){ + .Call(`_arrow_FixedSizeBinary__initialize` , byte_width) } -Timestamp__initialize1 <- function(unit) { - .Call(`_arrow_Timestamp__initialize1` , unit ) +Timestamp__initialize1 <- function(unit){ + .Call(`_arrow_Timestamp__initialize1` , unit) } -Timestamp__initialize2 <- function(unit, timezone) { - .Call(`_arrow_Timestamp__initialize2` , unit, timezone ) +Timestamp__initialize2 <- function(unit, timezone){ + .Call(`_arrow_Timestamp__initialize2` , unit, timezone) } -Time32__initialize <- function(unit) { - .Call(`_arrow_Time32__initialize` , unit ) +Time32__initialize <- function(unit){ + .Call(`_arrow_Time32__initialize` , unit) } -Time64__initialize <- function(unit) { - .Call(`_arrow_Time64__initialize` , unit ) +Time64__initialize <- function(unit){ + .Call(`_arrow_Time64__initialize` , unit) } -list__ <- function(x) { - .Call(`_arrow_list__` , x ) +list__ <- function(x){ + .Call(`_arrow_list__` , x) } -struct_ <- function(fields) { - .Call(`_arrow_struct_` , fields ) +struct_ <- function(fields){ + .Call(`_arrow_struct_` , fields) } -DataType__ToString <- function(type) { - .Call(`_arrow_DataType__ToString` , type ) +DataType__ToString <- function(type){ + .Call(`_arrow_DataType__ToString` , type) } -DataType__name <- function(type) { - .Call(`_arrow_DataType__name` , type ) +DataType__name <- function(type){ + .Call(`_arrow_DataType__name` , type) } -DataType__Equals <- function(lhs, rhs) { - .Call(`_arrow_DataType__Equals` , lhs, rhs ) +DataType__Equals <- function(lhs, rhs){ + .Call(`_arrow_DataType__Equals` , lhs, rhs) } -DataType__num_children <- function(type) { - .Call(`_arrow_DataType__num_children` , type ) +DataType__num_children <- function(type){ + .Call(`_arrow_DataType__num_children` , type) } -DataType__children_pointer <- function(type) { - .Call(`_arrow_DataType__children_pointer` , type ) +DataType__children_pointer <- function(type){ + .Call(`_arrow_DataType__children_pointer` , type) } -DataType__id <- function(type) { - .Call(`_arrow_DataType__id` , type ) +DataType__id <- function(type){ + .Call(`_arrow_DataType__id` , type) } -schema_ <- function(fields) { - .Call(`_arrow_schema_` , fields ) +schema_ <- function(fields){ + .Call(`_arrow_schema_` , fields) } -Schema__ToString <- function(s) { - .Call(`_arrow_Schema__ToString` , s ) +Schema__ToString <- function(s){ + .Call(`_arrow_Schema__ToString` , s) } -Schema__num_fields <- function(s) { - .Call(`_arrow_Schema__num_fields` , s ) +Schema__num_fields <- function(s){ + .Call(`_arrow_Schema__num_fields` , s) } -Schema__field <- function(s, i) { - .Call(`_arrow_Schema__field` , s, i ) +Schema__field <- function(s, i){ + .Call(`_arrow_Schema__field` , s, i) } -Schema__names <- function(schema) { - .Call(`_arrow_Schema__names` , schema ) +Schema__names <- function(schema){ + .Call(`_arrow_Schema__names` , schema) } -ListType__ToString <- function(type) { - .Call(`_arrow_ListType__ToString` , type ) +ListType__ToString <- function(type){ + .Call(`_arrow_ListType__ToString` , type) } -FixedWidthType__bit_width <- function(type) { - .Call(`_arrow_FixedWidthType__bit_width` , type ) +FixedWidthType__bit_width <- function(type){ + .Call(`_arrow_FixedWidthType__bit_width` , type) } -DateType__unit <- function(type) { - .Call(`_arrow_DateType__unit` , type ) +DateType__unit <- function(type){ + .Call(`_arrow_DateType__unit` , type) } -TimeType__unit <- function(type) { - .Call(`_arrow_TimeType__unit` , type ) +TimeType__unit <- function(type){ + .Call(`_arrow_TimeType__unit` , type) } -DecimalType__precision <- function(type) { - .Call(`_arrow_DecimalType__precision` , type ) +DecimalType__precision <- function(type){ + .Call(`_arrow_DecimalType__precision` , type) } -DecimalType__scale <- function(type) { - .Call(`_arrow_DecimalType__scale` , type ) +DecimalType__scale <- function(type){ + .Call(`_arrow_DecimalType__scale` , type) } -TimestampType__timezone <- function(type) { - .Call(`_arrow_TimestampType__timezone` , type ) +TimestampType__timezone <- function(type){ + .Call(`_arrow_TimestampType__timezone` , type) } -TimestampType__unit <- function(type) { - .Call(`_arrow_TimestampType__unit` , type ) +TimestampType__unit <- function(type){ + .Call(`_arrow_TimestampType__unit` , type) } -DictionaryType__initialize <- function(index_type, value_type, ordered) { - .Call(`_arrow_DictionaryType__initialize` , index_type, value_type, ordered ) +DictionaryType__initialize <- function(index_type, value_type, ordered){ + .Call(`_arrow_DictionaryType__initialize` , index_type, value_type, ordered) } -DictionaryType__index_type <- function(type) { - .Call(`_arrow_DictionaryType__index_type` , type ) +DictionaryType__index_type <- function(type){ + .Call(`_arrow_DictionaryType__index_type` , type) } -DictionaryType__value_type <- function(type) { - .Call(`_arrow_DictionaryType__value_type` , type ) +DictionaryType__value_type <- function(type){ + .Call(`_arrow_DictionaryType__value_type` , type) } -DictionaryType__name <- function(type) { - .Call(`_arrow_DictionaryType__name` , type ) +DictionaryType__name <- function(type){ + .Call(`_arrow_DictionaryType__name` , type) } -DictionaryType__ordered <- function(type) { - .Call(`_arrow_DictionaryType__ordered` , type ) +DictionaryType__ordered <- function(type){ + .Call(`_arrow_DictionaryType__ordered` , type) } -ipc___feather___TableWriter__SetDescription <- function(writer, description) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__SetDescription` , writer, description )) +ipc___feather___TableWriter__SetDescription <- function(writer, description){ + invisible(.Call(`_arrow_ipc___feather___TableWriter__SetDescription` , writer, description)) } -ipc___feather___TableWriter__SetNumRows <- function(writer, num_rows) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__SetNumRows` , writer, num_rows )) +ipc___feather___TableWriter__SetNumRows <- function(writer, num_rows){ + invisible(.Call(`_arrow_ipc___feather___TableWriter__SetNumRows` , writer, num_rows)) } -ipc___feather___TableWriter__Append <- function(writer, name, values) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__Append` , writer, name, values )) +ipc___feather___TableWriter__Append <- function(writer, name, values){ + invisible(.Call(`_arrow_ipc___feather___TableWriter__Append` , writer, name, values)) } -ipc___feather___TableWriter__Finalize <- function(writer) { - invisible(.Call(`_arrow_ipc___feather___TableWriter__Finalize` , writer )) +ipc___feather___TableWriter__Finalize <- function(writer){ + invisible(.Call(`_arrow_ipc___feather___TableWriter__Finalize` , writer)) } -ipc___feather___TableWriter__Open <- function(stream) { - .Call(`_arrow_ipc___feather___TableWriter__Open` , stream ) +ipc___feather___TableWriter__Open <- function(stream){ + .Call(`_arrow_ipc___feather___TableWriter__Open` , stream) } -ipc___TableWriter__RecordBatch__WriteFeather <- function(writer, batch) { - invisible(.Call(`_arrow_ipc___TableWriter__RecordBatch__WriteFeather` , writer, batch )) +ipc___TableWriter__RecordBatch__WriteFeather <- function(writer, batch){ + invisible(.Call(`_arrow_ipc___TableWriter__RecordBatch__WriteFeather` , writer, batch)) } -ipc___feather___TableReader__GetDescription <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__GetDescription` , reader ) +ipc___feather___TableReader__GetDescription <- function(reader){ + .Call(`_arrow_ipc___feather___TableReader__GetDescription` , reader) } -ipc___feather___TableReader__HasDescription <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__HasDescription` , reader ) +ipc___feather___TableReader__HasDescription <- function(reader){ + .Call(`_arrow_ipc___feather___TableReader__HasDescription` , reader) } -ipc___feather___TableReader__version <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__version` , reader ) +ipc___feather___TableReader__version <- function(reader){ + .Call(`_arrow_ipc___feather___TableReader__version` , reader) } -ipc___feather___TableReader__num_rows <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__num_rows` , reader ) +ipc___feather___TableReader__num_rows <- function(reader){ + .Call(`_arrow_ipc___feather___TableReader__num_rows` , reader) } -ipc___feather___TableReader__num_columns <- function(reader) { - .Call(`_arrow_ipc___feather___TableReader__num_columns` , reader ) +ipc___feather___TableReader__num_columns <- function(reader){ + .Call(`_arrow_ipc___feather___TableReader__num_columns` , reader) } -ipc___feather___TableReader__GetColumnName <- function(reader, i) { - .Call(`_arrow_ipc___feather___TableReader__GetColumnName` , reader, i ) +ipc___feather___TableReader__GetColumnName <- function(reader, i){ + .Call(`_arrow_ipc___feather___TableReader__GetColumnName` , reader, i) } -ipc___feather___TableReader__GetColumn <- function(reader, i) { - .Call(`_arrow_ipc___feather___TableReader__GetColumn` , reader, i ) +ipc___feather___TableReader__GetColumn <- function(reader, i){ + .Call(`_arrow_ipc___feather___TableReader__GetColumn` , reader, i) } -ipc___feather___TableReader__Read <- function(reader, columns) { - .Call(`_arrow_ipc___feather___TableReader__Read` , reader, columns ) +ipc___feather___TableReader__Read <- function(reader, columns){ + .Call(`_arrow_ipc___feather___TableReader__Read` , reader, columns) } -ipc___feather___TableReader__Open <- function(stream) { - .Call(`_arrow_ipc___feather___TableReader__Open` , stream ) +ipc___feather___TableReader__Open <- function(stream){ + .Call(`_arrow_ipc___feather___TableReader__Open` , stream) } -Field__initialize <- function(name, field, nullable) { - .Call(`_arrow_Field__initialize` , name, field, nullable ) +Field__initialize <- function(name, field, nullable){ + .Call(`_arrow_Field__initialize` , name, field, nullable) } -Field__ToString <- function(field) { - .Call(`_arrow_Field__ToString` , field ) +Field__ToString <- function(field){ + .Call(`_arrow_Field__ToString` , field) } -Field__name <- function(field) { - .Call(`_arrow_Field__name` , field ) +Field__name <- function(field){ + .Call(`_arrow_Field__name` , field) } -Field__Equals <- function(field, other) { - .Call(`_arrow_Field__Equals` , field, other ) +Field__Equals <- function(field, other){ + .Call(`_arrow_Field__Equals` , field, other) } -Field__nullable <- function(field) { - .Call(`_arrow_Field__nullable` , field ) +Field__nullable <- function(field){ + .Call(`_arrow_Field__nullable` , field) } -Field__type <- function(field) { - .Call(`_arrow_Field__type` , field ) +Field__type <- function(field){ + .Call(`_arrow_Field__type` , field) } -io___Readable__Read <- function(x, nbytes) { - .Call(`_arrow_io___Readable__Read` , x, nbytes ) +io___Readable__Read <- function(x, nbytes){ + .Call(`_arrow_io___Readable__Read` , x, nbytes) } -io___InputStream__Close <- function(x) { - invisible(.Call(`_arrow_io___InputStream__Close` , x )) +io___InputStream__Close <- function(x){ + invisible(.Call(`_arrow_io___InputStream__Close` , x)) } -io___OutputStream__Close <- function(x) { - invisible(.Call(`_arrow_io___OutputStream__Close` , x )) +io___OutputStream__Close <- function(x){ + invisible(.Call(`_arrow_io___OutputStream__Close` , x)) } -io___RandomAccessFile__GetSize <- function(x) { - .Call(`_arrow_io___RandomAccessFile__GetSize` , x ) +io___RandomAccessFile__GetSize <- function(x){ + .Call(`_arrow_io___RandomAccessFile__GetSize` , x) } -io___RandomAccessFile__supports_zero_copy <- function(x) { - .Call(`_arrow_io___RandomAccessFile__supports_zero_copy` , x ) +io___RandomAccessFile__supports_zero_copy <- function(x){ + .Call(`_arrow_io___RandomAccessFile__supports_zero_copy` , x) } -io___RandomAccessFile__Seek <- function(x, position) { - invisible(.Call(`_arrow_io___RandomAccessFile__Seek` , x, position )) +io___RandomAccessFile__Seek <- function(x, position){ + invisible(.Call(`_arrow_io___RandomAccessFile__Seek` , x, position)) } -io___RandomAccessFile__Tell <- function(x) { - .Call(`_arrow_io___RandomAccessFile__Tell` , x ) +io___RandomAccessFile__Tell <- function(x){ + .Call(`_arrow_io___RandomAccessFile__Tell` , x) } -io___MemoryMappedFile__Create <- function(path, size) { - .Call(`_arrow_io___MemoryMappedFile__Create` , path, size ) +io___MemoryMappedFile__Create <- function(path, size){ + .Call(`_arrow_io___MemoryMappedFile__Create` , path, size) } -io___MemoryMappedFile__Open <- function(path, mode) { - .Call(`_arrow_io___MemoryMappedFile__Open` , path, mode ) +io___MemoryMappedFile__Open <- function(path, mode){ + .Call(`_arrow_io___MemoryMappedFile__Open` , path, mode) } -io___MemoryMappedFile__Resize <- function(x, size) { - invisible(.Call(`_arrow_io___MemoryMappedFile__Resize` , x, size )) +io___MemoryMappedFile__Resize <- function(x, size){ + invisible(.Call(`_arrow_io___MemoryMappedFile__Resize` , x, size)) } -io___ReadableFile__Open <- function(path) { - .Call(`_arrow_io___ReadableFile__Open` , path ) +io___ReadableFile__Open <- function(path){ + .Call(`_arrow_io___ReadableFile__Open` , path) } -io___BufferReader__initialize <- function(buffer) { - .Call(`_arrow_io___BufferReader__initialize` , buffer ) +io___BufferReader__initialize <- function(buffer){ + .Call(`_arrow_io___BufferReader__initialize` , buffer) } -io___Writable__write <- function(stream, buf) { - invisible(.Call(`_arrow_io___Writable__write` , stream, buf )) +io___Writable__write <- function(stream, buf){ + invisible(.Call(`_arrow_io___Writable__write` , stream, buf)) } -io___OutputStream__Tell <- function(stream) { - .Call(`_arrow_io___OutputStream__Tell` , stream ) +io___OutputStream__Tell <- function(stream){ + .Call(`_arrow_io___OutputStream__Tell` , stream) } -io___FileOutputStream__Open <- function(path) { - .Call(`_arrow_io___FileOutputStream__Open` , path ) +io___FileOutputStream__Open <- function(path){ + .Call(`_arrow_io___FileOutputStream__Open` , path) } -io___BufferOutputStream__Create <- function(initial_capacity) { - .Call(`_arrow_io___BufferOutputStream__Create` , initial_capacity ) +io___BufferOutputStream__Create <- function(initial_capacity){ + .Call(`_arrow_io___BufferOutputStream__Create` , initial_capacity) } -io___BufferOutputStream__capacity <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__capacity` , stream ) +io___BufferOutputStream__capacity <- function(stream){ + .Call(`_arrow_io___BufferOutputStream__capacity` , stream) } -io___BufferOutputStream__Finish <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__Finish` , stream ) +io___BufferOutputStream__Finish <- function(stream){ + .Call(`_arrow_io___BufferOutputStream__Finish` , stream) } -io___BufferOutputStream__Tell <- function(stream) { - .Call(`_arrow_io___BufferOutputStream__Tell` , stream ) +io___BufferOutputStream__Tell <- function(stream){ + .Call(`_arrow_io___BufferOutputStream__Tell` , stream) } -io___BufferOutputStream__Write <- function(stream, bytes) { - invisible(.Call(`_arrow_io___BufferOutputStream__Write` , stream, bytes )) +io___BufferOutputStream__Write <- function(stream, bytes){ + invisible(.Call(`_arrow_io___BufferOutputStream__Write` , stream, bytes)) } -io___MockOutputStream__initialize <- function() { - .Call(`_arrow_io___MockOutputStream__initialize` ) +io___MockOutputStream__initialize <- function(){ + .Call(`_arrow_io___MockOutputStream__initialize` ) } -io___MockOutputStream__GetExtentBytesWritten <- function(stream) { - .Call(`_arrow_io___MockOutputStream__GetExtentBytesWritten` , stream ) +io___MockOutputStream__GetExtentBytesWritten <- function(stream){ + .Call(`_arrow_io___MockOutputStream__GetExtentBytesWritten` , stream) } -io___FixedSizeBufferWriter__initialize <- function(buffer) { - .Call(`_arrow_io___FixedSizeBufferWriter__initialize` , buffer ) +io___FixedSizeBufferWriter__initialize <- function(buffer){ + .Call(`_arrow_io___FixedSizeBufferWriter__initialize` , buffer) } -MemoryPool__default <- function() { - .Call(`_arrow_MemoryPool__default` ) +MemoryPool__default <- function(){ + .Call(`_arrow_MemoryPool__default` ) } -MemoryPool__bytes_allocated <- function(pool) { - .Call(`_arrow_MemoryPool__bytes_allocated` , pool ) +MemoryPool__bytes_allocated <- function(pool){ + .Call(`_arrow_MemoryPool__bytes_allocated` , pool) } -MemoryPool__max_memory <- function(pool) { - .Call(`_arrow_MemoryPool__max_memory` , pool ) +MemoryPool__max_memory <- function(pool){ + .Call(`_arrow_MemoryPool__max_memory` , pool) } -ipc___Message__body_length <- function(message) { - .Call(`_arrow_ipc___Message__body_length` , message ) +ipc___Message__body_length <- function(message){ + .Call(`_arrow_ipc___Message__body_length` , message) } -ipc___Message__metadata <- function(message) { - .Call(`_arrow_ipc___Message__metadata` , message ) +ipc___Message__metadata <- function(message){ + .Call(`_arrow_ipc___Message__metadata` , message) } -ipc___Message__body <- function(message) { - .Call(`_arrow_ipc___Message__body` , message ) +ipc___Message__body <- function(message){ + .Call(`_arrow_ipc___Message__body` , message) } -ipc___Message__Verify <- function(message) { - .Call(`_arrow_ipc___Message__Verify` , message ) +ipc___Message__Verify <- function(message){ + .Call(`_arrow_ipc___Message__Verify` , message) } -ipc___Message__type <- function(message) { - .Call(`_arrow_ipc___Message__type` , message ) +ipc___Message__type <- function(message){ + .Call(`_arrow_ipc___Message__type` , message) } -ipc___Message__Equals <- function(x, y) { - .Call(`_arrow_ipc___Message__Equals` , x, y ) +ipc___Message__Equals <- function(x, y){ + .Call(`_arrow_ipc___Message__Equals` , x, y) } -ipc___ReadRecordBatch__Message__Schema <- function(message, schema) { - .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema` , message, schema ) +ipc___ReadRecordBatch__Message__Schema <- function(message, schema){ + .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema` , message, schema) } -ipc___ReadSchema_InputStream <- function(stream) { - .Call(`_arrow_ipc___ReadSchema_InputStream` , stream ) +ipc___ReadSchema_InputStream <- function(stream){ + .Call(`_arrow_ipc___ReadSchema_InputStream` , stream) } -ipc___MessageReader__Open <- function(stream) { - .Call(`_arrow_ipc___MessageReader__Open` , stream ) +ipc___MessageReader__Open <- function(stream){ + .Call(`_arrow_ipc___MessageReader__Open` , stream) } -ipc___MessageReader__ReadNextMessage <- function(reader) { - .Call(`_arrow_ipc___MessageReader__ReadNextMessage` , reader ) +ipc___MessageReader__ReadNextMessage <- function(reader){ + .Call(`_arrow_ipc___MessageReader__ReadNextMessage` , reader) } -ipc___ReadMessage <- function(stream) { - .Call(`_arrow_ipc___ReadMessage` , stream ) +ipc___ReadMessage <- function(stream){ + .Call(`_arrow_ipc___ReadMessage` , stream) } -read_parquet_file <- function(filename) { - .Call(`_arrow_read_parquet_file` , filename ) +read_parquet_file <- function(filename){ + .Call(`_arrow_read_parquet_file` , filename) } -RecordBatch__num_columns <- function(x) { - .Call(`_arrow_RecordBatch__num_columns` , x ) +RecordBatch__num_columns <- function(x){ + .Call(`_arrow_RecordBatch__num_columns` , x) } -RecordBatch__num_rows <- function(x) { - .Call(`_arrow_RecordBatch__num_rows` , x ) +RecordBatch__num_rows <- function(x){ + .Call(`_arrow_RecordBatch__num_rows` , x) } -RecordBatch__schema <- function(x) { - .Call(`_arrow_RecordBatch__schema` , x ) +RecordBatch__schema <- function(x){ + .Call(`_arrow_RecordBatch__schema` , x) } -RecordBatch__columns <- function(batch) { - .Call(`_arrow_RecordBatch__columns` , batch ) +RecordBatch__columns <- function(batch){ + .Call(`_arrow_RecordBatch__columns` , batch) } -RecordBatch__column <- function(batch, i) { - .Call(`_arrow_RecordBatch__column` , batch, i ) +RecordBatch__column <- function(batch, i){ + .Call(`_arrow_RecordBatch__column` , batch, i) } -RecordBatch__from_dataframe <- function(tbl) { - .Call(`_arrow_RecordBatch__from_dataframe` , tbl ) +RecordBatch__from_dataframe <- function(tbl){ + .Call(`_arrow_RecordBatch__from_dataframe` , tbl) } -RecordBatch__Equals <- function(self, other) { - .Call(`_arrow_RecordBatch__Equals` , self, other ) +RecordBatch__Equals <- function(self, other){ + .Call(`_arrow_RecordBatch__Equals` , self, other) } -RecordBatch__RemoveColumn <- function(batch, i) { - .Call(`_arrow_RecordBatch__RemoveColumn` , batch, i ) +RecordBatch__RemoveColumn <- function(batch, i){ + .Call(`_arrow_RecordBatch__RemoveColumn` , batch, i) } -RecordBatch__column_name <- function(batch, i) { - .Call(`_arrow_RecordBatch__column_name` , batch, i ) +RecordBatch__column_name <- function(batch, i){ + .Call(`_arrow_RecordBatch__column_name` , batch, i) } -RecordBatch__names <- function(batch) { - .Call(`_arrow_RecordBatch__names` , batch ) +RecordBatch__names <- function(batch){ + .Call(`_arrow_RecordBatch__names` , batch) } -RecordBatch__Slice1 <- function(self, offset) { - .Call(`_arrow_RecordBatch__Slice1` , self, offset ) +RecordBatch__Slice1 <- function(self, offset){ + .Call(`_arrow_RecordBatch__Slice1` , self, offset) } -RecordBatch__Slice2 <- function(self, offset, length) { - .Call(`_arrow_RecordBatch__Slice2` , self, offset, length ) +RecordBatch__Slice2 <- function(self, offset, length){ + .Call(`_arrow_RecordBatch__Slice2` , self, offset, length) } -ipc___SerializeRecordBatch__Raw <- function(batch) { - .Call(`_arrow_ipc___SerializeRecordBatch__Raw` , batch ) +ipc___SerializeRecordBatch__Raw <- function(batch){ + .Call(`_arrow_ipc___SerializeRecordBatch__Raw` , batch) } -ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema) { - .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema` , stream, schema ) +ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema){ + .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema` , stream, schema) } -RecordBatch__from_arrays <- function(schema_sxp, lst) { - .Call(`_arrow_RecordBatch__from_arrays` , schema_sxp, lst ) +RecordBatch__from_arrays <- function(schema_sxp, lst){ + .Call(`_arrow_RecordBatch__from_arrays` , schema_sxp, lst) } -RecordBatchReader__schema <- function(reader) { - .Call(`_arrow_RecordBatchReader__schema` , reader ) +RecordBatchReader__schema <- function(reader){ + .Call(`_arrow_RecordBatchReader__schema` , reader) } -RecordBatchReader__ReadNext <- function(reader) { - .Call(`_arrow_RecordBatchReader__ReadNext` , reader ) +RecordBatchReader__ReadNext <- function(reader){ + .Call(`_arrow_RecordBatchReader__ReadNext` , reader) } -ipc___RecordBatchStreamReader__Open <- function(stream) { - .Call(`_arrow_ipc___RecordBatchStreamReader__Open` , stream ) +ipc___RecordBatchStreamReader__Open <- function(stream){ + .Call(`_arrow_ipc___RecordBatchStreamReader__Open` , stream) } -ipc___RecordBatchStreamReader__batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchStreamReader__batches` , reader ) +ipc___RecordBatchStreamReader__batches <- function(reader){ + .Call(`_arrow_ipc___RecordBatchStreamReader__batches` , reader) } -ipc___RecordBatchFileReader__schema <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__schema` , reader ) +ipc___RecordBatchFileReader__schema <- function(reader){ + .Call(`_arrow_ipc___RecordBatchFileReader__schema` , reader) } -ipc___RecordBatchFileReader__num_record_batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches` , reader ) +ipc___RecordBatchFileReader__num_record_batches <- function(reader){ + .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches` , reader) } -ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i) { - .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch` , reader, i ) +ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i){ + .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch` , reader, i) } -ipc___RecordBatchFileReader__Open <- function(file) { - .Call(`_arrow_ipc___RecordBatchFileReader__Open` , file ) +ipc___RecordBatchFileReader__Open <- function(file){ + .Call(`_arrow_ipc___RecordBatchFileReader__Open` , file) } -Table__from_RecordBatchFileReader <- function(reader) { - .Call(`_arrow_Table__from_RecordBatchFileReader` , reader ) +Table__from_RecordBatchFileReader <- function(reader){ + .Call(`_arrow_Table__from_RecordBatchFileReader` , reader) } -Table__from_RecordBatchStreamReader <- function(reader) { - .Call(`_arrow_Table__from_RecordBatchStreamReader` , reader ) +Table__from_RecordBatchStreamReader <- function(reader){ + .Call(`_arrow_Table__from_RecordBatchStreamReader` , reader) } -ipc___RecordBatchFileReader__batches <- function(reader) { - .Call(`_arrow_ipc___RecordBatchFileReader__batches` , reader ) +ipc___RecordBatchFileReader__batches <- function(reader){ + .Call(`_arrow_ipc___RecordBatchFileReader__batches` , reader) } -ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch` , batch_writer, batch )) +ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch){ + invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch` , batch_writer, batch)) } -ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable` , batch_writer, table )) +ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table){ + invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable` , batch_writer, table)) } -ipc___RecordBatchWriter__Close <- function(batch_writer) { - invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close` , batch_writer )) +ipc___RecordBatchWriter__Close <- function(batch_writer){ + invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close` , batch_writer)) } -ipc___RecordBatchFileWriter__Open <- function(stream, schema) { - .Call(`_arrow_ipc___RecordBatchFileWriter__Open` , stream, schema ) +ipc___RecordBatchFileWriter__Open <- function(stream, schema){ + .Call(`_arrow_ipc___RecordBatchFileWriter__Open` , stream, schema) } -ipc___RecordBatchStreamWriter__Open <- function(stream, schema) { - .Call(`_arrow_ipc___RecordBatchStreamWriter__Open` , stream, schema ) +ipc___RecordBatchStreamWriter__Open <- function(stream, schema){ + .Call(`_arrow_ipc___RecordBatchStreamWriter__Open` , stream, schema) } -Table__from_dataframe <- function(tbl) { - .Call(`_arrow_Table__from_dataframe` , tbl ) +Table__from_dataframe <- function(tbl){ + .Call(`_arrow_Table__from_dataframe` , tbl) } -Table__num_columns <- function(x) { - .Call(`_arrow_Table__num_columns` , x ) +Table__num_columns <- function(x){ + .Call(`_arrow_Table__num_columns` , x) } -Table__num_rows <- function(x) { - .Call(`_arrow_Table__num_rows` , x ) +Table__num_rows <- function(x){ + .Call(`_arrow_Table__num_rows` , x) } -Table__schema <- function(x) { - .Call(`_arrow_Table__schema` , x ) +Table__schema <- function(x){ + .Call(`_arrow_Table__schema` , x) } -Table__column <- function(table, i) { - .Call(`_arrow_Table__column` , table, i ) +Table__column <- function(table, i){ + .Call(`_arrow_Table__column` , table, i) } -Table__columns <- function(table) { - .Call(`_arrow_Table__columns` , table ) +Table__columns <- function(table){ + .Call(`_arrow_Table__columns` , table) } -Table__from_dots <- function(lst, schema_sxp) { - .Call(`_arrow_Table__from_dots` , lst, schema_sxp ) +Table__from_dots <- function(lst, schema_sxp){ + .Call(`_arrow_Table__from_dots` , lst, schema_sxp) } -GetCpuThreadPoolCapacity <- function() { - .Call(`_arrow_GetCpuThreadPoolCapacity` ) +GetCpuThreadPoolCapacity <- function(){ + .Call(`_arrow_GetCpuThreadPoolCapacity` ) } -SetCpuThreadPoolCapacity <- function(threads) { - invisible(.Call(`_arrow_SetCpuThreadPoolCapacity` , threads )) +SetCpuThreadPoolCapacity <- function(threads){ + invisible(.Call(`_arrow_SetCpuThreadPoolCapacity` , threads)) } diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index db35c6b13a3..69f583e3c21 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -1,9 +1,6 @@ # pak::pkg_install("romainfrancois/decor") library(decor) -# pak::pkg_install("romainfrancois/rap") -library(rap) - library(dplyr) library(stringr) library(purrr) @@ -11,90 +8,82 @@ library(glue) decorations <- cpp_decorations() %>% filter(decoration == "arrow::export") %>% - rap( ~ decor:::parse_cpp_function(context)) - -glue_collapse_or_empty <- function(...) { - res <- glue_collapse(...) - if(length(res)) { - res - } else { - "" - } + # the three lines below can be expressed with rap() + # more concisely + # rap( ~ decor:::parse_cpp_function(context)) + mutate(functions = map(context, decor:::parse_cpp_function)) %>% + { bind_cols(., bind_rows(pull(., functions))) } %>% + select(-functions) + +glue_collapse_data <- function(data, ..., sep = ", ", last = "") { + res <- glue_collapse(glue_data(data, ...), sep = sep, last = last) + if(length(res) == 0) res <- "" + res } -sexp_params <- function(args){ - glue_collapse_or_empty(glue_data(args, "SEXP {name}_sexp"), sep = ", ") -} - -real_params <- function(args){ - glue_collapse_or_empty(glue_data(args, "{type} {name}"), sep = ", ") -} - -input_params <- function(args) { - glue_collapse_or_empty( - glue_data(args, "Rcpp::traits::input_parameter<{type}>::type {name}({name}_sexp);"), - sep = "\n" - ) -} - -list_params <- function(args) { - glue_collapse_or_empty( - glue_data(args, "{name}"), - sep = ", " - ) -} +# sexp_params <- function(args){ +# glue_collapse_data(args, "SEXP {name}_sexp") +# } +# +# real_params <- function(args){ +# glue_collapse_data(args, "{type} {name}") +# } +# +# input_params <- function(args) { +# glue_collapse_data(args, "Rcpp::traits::input_parameter<{type}>::type {name}({name}_sexp);", sep = "\n", last = "\n") +# } wrap_call <- function(name, return_type, args) { - call <- glue::glue('{name}( {list_params(args)})') + call <- glue::glue('{name}({list_params})', list_params = glue_collapse_data(args, "{name}")) if(return_type == "void") { - glue::glue("{call};\n return R_NilValue;") + glue::glue("\t{call};\n\treturn R_NilValue;", .trim = FALSE) } else { - glue::glue("Rcpp::Shield rcpp_result_gen(Rcpp::wrap({call}));\n return rcpp_result_gen;") + glue::glue("\treturn Rcpp::wrap({call});") } } - -cpp_function_definitions <- function(name, return_type, args) { - glue::glue( - ' +cpp_functions_definitions <- decorations %>% + select(name, return_type, args, file, line) %>% + pmap_chr(function(name, return_type, args, file, line){ + glue::glue(' + // {basename(file)}:{line} #if defined(ARROW_R_WITH_ARROW) - {return_type} {name}({real_params(args)}); - SEXP _arrow_{name}({sexp_params(args)}){{ - BEGIN_RCPP - {input_params(args)}{wrap_call(name, return_type, args)} - END_RCPP + {return_type} {name}({real_params}); + SEXP _arrow_{name}({sexp_params}){{ + BEGIN_RCPP + {input_params}{return_line}{wrap_call(name, return_type, args)} + END_RCPP }} #else - SEXP _arrow_{name}({sexp_params(args)}){{ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + SEXP _arrow_{name}({sexp_params}){{ + \tRf_error("arrow C++ library not available. Cannot call {name}(). "); }} #endif ', - sep = "\n" - ) -} - -definitions <- wap(decorations, - character() ~ cpp_function_definitions(name, return_type, args) -) %>% - glue_collapse(sep = "\n") - -registration <- wap(decorations, - character() ~ glue('\t\t{{ "_arrow_{name}", (DL_FUNC)& _arrow_{name}, {nrow(args)} }}, ') -) %>% + sep = "\n", + real_params = glue_collapse_data(args, "{type} {name}"), + sexp_params = glue_collapse_data(args, "SEXP {name}_sexp"), + input_params = glue_collapse_data(args, "\tRcpp::traits::input_parameter<{type}>::type {name}({name}_sexp);", sep = "\n"), + return_line = if(nrow(args)) "\n" else "" + ) + }) %>% + glue_collapse(sep = "\n") + +cpp_functions_registration <- decorations %>% + select(name, return_type, args) %>% + pmap_chr(function(name, return_type, args){ + glue('\t\t{{ "_arrow_{name}", (DL_FUNC)& _arrow_{name}, {nrow(args)}}}, ') + }) %>% glue_collapse(sep = "\n") - -writeLines(glue::glue(' +writeLines(con = "src/generated.cpp", glue::glue(' // Generated by using data-raw/codegen.R -> do not edit by hand #include "./arrow_types.h" #include using namespace Rcpp; -{definitions} +{cpp_functions_definitions} extern "C" SEXP _arrow_available() {{ return Rf_ScalarLogical( @@ -108,7 +97,7 @@ return Rf_ScalarLogical( static const R_CallMethodDef arrow_CallEntries[] = {{ \t\t{{ "_arrow_available", (DL_FUNC)& _arrow_available, 0 }}, -{registration} +{cpp_functions_registration} \t\t{{NULL, NULL, 0}} }}; @@ -117,44 +106,37 @@ extern "C" void R_init_arrow(DllInfo* dll){{ R_useDynamicSymbols(dll, FALSE); }} -'), "src/generated.cpp") - - -r_function <- function(name, return_type, args) { - formals <- list_params(args) - params <- if (nrow(args)) { - paste0(", ", list_params(args)) - } else { - "" - } - call <- if(return_type == "void") { - glue::glue('invisible(.Call(`_arrow_{name}` {params} ))') - } else { - glue::glue('.Call(`_arrow_{name}` {params} )') - } - - glue::glue( - ' - {name} <- function({list_params(args)}) {{ +') ) + +r_functions <- decorations %>% + select(name, return_type, args) %>% + pmap_chr(function(name, return_type, args) { + params <- if (nrow(args)) { + paste0(", ", glue_collapse_data(args, "{name}")) + } else { + "" + } + call <- if(return_type == "void") { + glue::glue('invisible(.Call(`_arrow_{name}` {params}))') + } else { + glue::glue('.Call(`_arrow_{name}` {params})') + } + + glue::glue(' + {name} <- function({list_params}){{ {call} }} ', - sep = "\n" - ) -} - -rfunctions <- wap(decorations, - character() ~ r_function(name, return_type, args) -) %>% - glue_collapse(sep = "\n") + list_params = glue_collapse_data(args, "{name}"), + sep = "\n", + ) + }) %>% + glue_collapse(sep = "\n") -writeLines(glue::glue(' +writeLines(con = "R/generated.R", glue::glue(' # Generated by using data-raw/codegen.R -> do not edit by hand -{rfunctions} - -'), "R/generated.R") - - +{r_functions} +')) diff --git a/r/src/generated.cpp b/r/src/generated.cpp index 429135bde9e..1ccd55426c7 100644 --- a/r/src/generated.cpp +++ b/r/src/generated.cpp @@ -4,3407 +4,3196 @@ using namespace Rcpp; +// array.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__Slice1(const std::shared_ptr& array, int offset); SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Slice1( array, offset))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + return Rcpp::wrap(Array__Slice1(array, offset)); +END_RCPP } #else SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__Slice1(). "); } #endif +// array.cpp:31 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__Slice2(const std::shared_ptr& array, int offset, int length); SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp); -Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Slice2( array, offset, length))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + Rcpp::traits::input_parameter::type length(length_sexp); + return Rcpp::wrap(Array__Slice2(array, offset, length)); +END_RCPP } #else SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__Slice2(). "); } #endif +// array.cpp:37 #if defined(ARROW_R_WITH_ARROW) bool Array__IsNull(const std::shared_ptr& x, int i); SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__IsNull( x, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(Array__IsNull(x, i)); +END_RCPP } #else SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__IsNull(). "); } #endif +// array.cpp:40 #if defined(ARROW_R_WITH_ARROW) bool Array__IsValid(const std::shared_ptr& x, int i); SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__IsValid( x, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(Array__IsValid(x, i)); +END_RCPP } #else SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__IsValid(). "); } #endif +// array.cpp:45 #if defined(ARROW_R_WITH_ARROW) int Array__length(const std::shared_ptr& x); SEXP _arrow_Array__length(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__length( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__length(x)); +END_RCPP } #else SEXP _arrow_Array__length(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__length(). "); } #endif +// array.cpp:48 #if defined(ARROW_R_WITH_ARROW) int Array__offset(const std::shared_ptr& x); SEXP _arrow_Array__offset(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__offset( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__offset(x)); +END_RCPP } #else SEXP _arrow_Array__offset(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__offset(). "); } #endif +// array.cpp:51 #if defined(ARROW_R_WITH_ARROW) int Array__null_count(const std::shared_ptr& x); SEXP _arrow_Array__null_count(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__null_count( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__null_count(x)); +END_RCPP } #else SEXP _arrow_Array__null_count(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__null_count(). "); } #endif +// array.cpp:54 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__type(const std::shared_ptr& x); SEXP _arrow_Array__type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__type( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__type(x)); +END_RCPP } #else SEXP _arrow_Array__type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__type(). "); } #endif +// array.cpp:59 #if defined(ARROW_R_WITH_ARROW) std::string Array__ToString(const std::shared_ptr& x); SEXP _arrow_Array__ToString(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__ToString( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__ToString(x)); +END_RCPP } #else SEXP _arrow_Array__ToString(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__ToString(). "); } #endif +// array.cpp:64 #if defined(ARROW_R_WITH_ARROW) arrow::Type::type Array__type_id(const std::shared_ptr& x); SEXP _arrow_Array__type_id(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__type_id( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Array__type_id(x)); +END_RCPP } #else SEXP _arrow_Array__type_id(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__type_id(). "); } #endif +// array.cpp:69 #if defined(ARROW_R_WITH_ARROW) bool Array__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); -Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Equals( lhs, rhs))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); + Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); + return Rcpp::wrap(Array__Equals(lhs, rhs)); +END_RCPP } #else SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__Equals(). "); } #endif +// array.cpp:75 #if defined(ARROW_R_WITH_ARROW) bool Array__ApproxEquals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); -Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__ApproxEquals( lhs, rhs))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); + Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); + return Rcpp::wrap(Array__ApproxEquals(lhs, rhs)); +END_RCPP } #else SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__ApproxEquals(). "); } #endif +// array.cpp:81 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__data(const std::shared_ptr& array); SEXP _arrow_Array__data(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__data( array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + return Rcpp::wrap(Array__data(array)); +END_RCPP } #else SEXP _arrow_Array__data(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__data(). "); } #endif +// array.cpp:87 #if defined(ARROW_R_WITH_ARROW) bool Array__RangeEquals(const std::shared_ptr& self, const std::shared_ptr& other, int start_idx, int end_idx, int other_start_idx); SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type self(self_sexp); -Rcpp::traits::input_parameter&>::type other(other_sexp); -Rcpp::traits::input_parameter::type start_idx(start_idx_sexp); -Rcpp::traits::input_parameter::type end_idx(end_idx_sexp); -Rcpp::traits::input_parameter::type other_start_idx(other_start_idx_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__RangeEquals( self, other, start_idx, end_idx, other_start_idx))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); + Rcpp::traits::input_parameter&>::type other(other_sexp); + Rcpp::traits::input_parameter::type start_idx(start_idx_sexp); + Rcpp::traits::input_parameter::type end_idx(end_idx_sexp); + Rcpp::traits::input_parameter::type other_start_idx(other_start_idx_sexp); + return Rcpp::wrap(Array__RangeEquals(self, other, start_idx, end_idx, other_start_idx)); +END_RCPP } #else SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__RangeEquals(). "); } #endif +// array.cpp:94 #if defined(ARROW_R_WITH_ARROW) LogicalVector Array__Mask(const std::shared_ptr& array); SEXP _arrow_Array__Mask(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__Mask( array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + return Rcpp::wrap(Array__Mask(array)); +END_RCPP } #else SEXP _arrow_Array__Mask(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__Mask(). "); } #endif +// array.cpp:110 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryArray__indices(const std::shared_ptr& array); SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryArray__indices( array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + return Rcpp::wrap(DictionaryArray__indices(array)); +END_RCPP } #else SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryArray__indices(). "); } #endif +// array.cpp:116 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryArray__dictionary(const std::shared_ptr& array); SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryArray__dictionary( array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + return Rcpp::wrap(DictionaryArray__dictionary(array)); +END_RCPP } #else SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryArray__dictionary(). "); } #endif +// array__to_vector.cpp:669 #if defined(ARROW_R_WITH_ARROW) SEXP Array__as_vector(const std::shared_ptr& array); SEXP _arrow_Array__as_vector(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__as_vector( array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + return Rcpp::wrap(Array__as_vector(array)); +END_RCPP } #else SEXP _arrow_Array__as_vector(SEXP array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__as_vector(). "); } #endif +// array__to_vector.cpp:674 #if defined(ARROW_R_WITH_ARROW) SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__as_vector( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__as_vector(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__as_vector(). "); } #endif +// array__to_vector.cpp:680 #if defined(ARROW_R_WITH_ARROW) Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& batch, bool use_threads); SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp); -Rcpp::traits::input_parameter::type use_threads(use_threads_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__to_dataframe( batch, use_threads))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + Rcpp::traits::input_parameter::type use_threads(use_threads_sexp); + return Rcpp::wrap(RecordBatch__to_dataframe(batch, use_threads)); +END_RCPP } #else SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__to_dataframe(). "); } #endif +// array__to_vector.cpp:702 #if defined(ARROW_R_WITH_ARROW) Rcpp::List Table__to_dataframe(const std::shared_ptr& table, bool use_threads); SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type table(table_sexp); -Rcpp::traits::input_parameter::type use_threads(use_threads_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__to_dataframe( table, use_threads))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); + Rcpp::traits::input_parameter::type use_threads(use_threads_sexp); + return Rcpp::wrap(Table__to_dataframe(table, use_threads)); +END_RCPP } #else SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__to_dataframe(). "); } #endif +// array_from_vector.cpp:959 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__infer_type(SEXP x); SEXP _arrow_Array__infer_type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__infer_type( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp); + return Rcpp::wrap(Array__infer_type(x)); +END_RCPP } #else SEXP _arrow_Array__infer_type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__infer_type(). "); } #endif +// array_from_vector.cpp:964 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__from_vector(SEXP x, SEXP s_type); SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type x(x_sexp); -Rcpp::traits::input_parameter::type s_type(s_type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__from_vector( x, s_type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp); + Rcpp::traits::input_parameter::type s_type(s_type_sexp); + return Rcpp::wrap(Array__from_vector(x, s_type)); +END_RCPP } #else SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__from_vector(). "); } #endif +// array_from_vector.cpp:979 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, SEXP s_type); SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type chunks(chunks_sexp); -Rcpp::traits::input_parameter::type s_type(s_type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__from_list( chunks, s_type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type chunks(chunks_sexp); + Rcpp::traits::input_parameter::type s_type(s_type_sexp); + return Rcpp::wrap(ChunkedArray__from_list(chunks, s_type)); +END_RCPP } #else SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__from_list(). "); } #endif +// arraydata.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ArrayData__get_type(const std::shared_ptr& x); SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_type( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(ArrayData__get_type(x)); +END_RCPP } #else SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ArrayData__get_type(). "); } #endif +// arraydata.cpp:31 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_length(const std::shared_ptr& x); SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_length( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(ArrayData__get_length(x)); +END_RCPP } #else SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ArrayData__get_length(). "); } #endif +// arraydata.cpp:36 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_null_count(const std::shared_ptr& x); SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_null_count( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(ArrayData__get_null_count(x)); +END_RCPP } #else SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ArrayData__get_null_count(). "); } #endif +// arraydata.cpp:41 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_offset(const std::shared_ptr& x); SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__get_offset( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(ArrayData__get_offset(x)); +END_RCPP } #else SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ArrayData__get_offset(). "); } #endif +// arraydata.cpp:46 #if defined(ARROW_R_WITH_ARROW) List ArrayData__buffers(const std::shared_ptr& x); SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ArrayData__buffers( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(ArrayData__buffers(x)); +END_RCPP } #else SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ArrayData__buffers(). "); } #endif +// buffer.cpp:22 #if defined(ARROW_R_WITH_ARROW) bool Buffer__is_mutable(const std::shared_ptr& buffer); SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__is_mutable( buffer))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + return Rcpp::wrap(Buffer__is_mutable(buffer)); +END_RCPP } #else SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Buffer__is_mutable(). "); } #endif +// buffer.cpp:27 #if defined(ARROW_R_WITH_ARROW) void Buffer__ZeroPadding(const std::shared_ptr& buffer); SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Buffer__ZeroPadding( buffer); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + Buffer__ZeroPadding(buffer); + return R_NilValue; +END_RCPP } #else SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Buffer__ZeroPadding(). "); } #endif +// buffer.cpp:32 #if defined(ARROW_R_WITH_ARROW) int64_t Buffer__capacity(const std::shared_ptr& buffer); SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__capacity( buffer))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + return Rcpp::wrap(Buffer__capacity(buffer)); +END_RCPP } #else SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Buffer__capacity(). "); } #endif +// buffer.cpp:37 #if defined(ARROW_R_WITH_ARROW) int64_t Buffer__size(const std::shared_ptr& buffer); SEXP _arrow_Buffer__size(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Buffer__size( buffer))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + return Rcpp::wrap(Buffer__size(buffer)); +END_RCPP } #else SEXP _arrow_Buffer__size(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Buffer__size(). "); } #endif +// buffer.cpp:42 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr r___RBuffer__initialize(SEXP x); SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(r___RBuffer__initialize( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp); + return Rcpp::wrap(r___RBuffer__initialize(x)); +END_RCPP } #else SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call r___RBuffer__initialize(). "); } #endif +// chunkedarray.cpp:25 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__length(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__length( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__length(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__length(). "); } #endif +// chunkedarray.cpp:30 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__null_count(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__null_count( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__null_count(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__null_count(). "); } #endif +// chunkedarray.cpp:35 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__num_chunks(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__num_chunks( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__num_chunks(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__num_chunks(). "); } #endif +// chunkedarray.cpp:40 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__chunk(const std::shared_ptr& chunked_array, int i); SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__chunk( chunked_array, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(ChunkedArray__chunk(chunked_array, i)); +END_RCPP } #else SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunk(). "); } #endif +// chunkedarray.cpp:46 #if defined(ARROW_R_WITH_ARROW) List ChunkedArray__chunks(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__chunks( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__chunks(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunks(). "); } #endif +// chunkedarray.cpp:51 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__type(const std::shared_ptr& chunked_array); SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__type( chunked_array))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + return Rcpp::wrap(ChunkedArray__type(chunked_array)); +END_RCPP } #else SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__type(). "); } #endif +// chunkedarray.cpp:57 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkArray__Slice1(const std::shared_ptr& chunked_array, int offset); SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkArray__Slice1( chunked_array, offset))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + return Rcpp::wrap(ChunkArray__Slice1(chunked_array, offset)); +END_RCPP } #else SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice1(). "); } #endif +// chunkedarray.cpp:63 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkArray__Slice2(const std::shared_ptr& chunked_array, int offset, int length); SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp); -Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkArray__Slice2( chunked_array, offset, length))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + Rcpp::traits::input_parameter::type length(length_sexp); + return Rcpp::wrap(ChunkArray__Slice2(chunked_array, offset, length)); +END_RCPP } #else SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice2(). "); } #endif +// column.cpp:22 #if defined(ARROW_R_WITH_ARROW) int Column__length(const std::shared_ptr& column); SEXP _arrow_Column__length(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__length( column))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp); + return Rcpp::wrap(Column__length(column)); +END_RCPP } #else SEXP _arrow_Column__length(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Column__length(). "); } #endif +// column.cpp:27 #if defined(ARROW_R_WITH_ARROW) int Column__null_count(const std::shared_ptr& column); SEXP _arrow_Column__null_count(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__null_count( column))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp); + return Rcpp::wrap(Column__null_count(column)); +END_RCPP } #else SEXP _arrow_Column__null_count(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Column__null_count(). "); } #endif +// column.cpp:32 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Column__type(const std::shared_ptr& column); SEXP _arrow_Column__type(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__type( column))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp); + return Rcpp::wrap(Column__type(column)); +END_RCPP } #else SEXP _arrow_Column__type(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Column__type(). "); } #endif +// column.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Column__data(const std::shared_ptr& column); SEXP _arrow_Column__data(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type column(column_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Column__data( column))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type column(column_sexp); + return Rcpp::wrap(Column__data(column)); +END_RCPP } #else SEXP _arrow_Column__data(SEXP column_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Column__data(). "); } #endif +// compression.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr util___Codec__Create(arrow::Compression::type codec); SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type codec(codec_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(util___Codec__Create( codec))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type codec(codec_sexp); + return Rcpp::wrap(util___Codec__Create(codec)); +END_RCPP } #else SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call util___Codec__Create(). "); } #endif +// compression.cpp:29 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___CompressedOutputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type codec(codec_sexp); -Rcpp::traits::input_parameter&>::type raw(raw_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___CompressedOutputStream__Make( codec, raw))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type codec(codec_sexp); + Rcpp::traits::input_parameter&>::type raw(raw_sexp); + return Rcpp::wrap(io___CompressedOutputStream__Make(codec, raw)); +END_RCPP } #else SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___CompressedOutputStream__Make(). "); } #endif +// compression.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___CompressedInputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type codec(codec_sexp); -Rcpp::traits::input_parameter&>::type raw(raw_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___CompressedInputStream__Make( codec, raw))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type codec(codec_sexp); + Rcpp::traits::input_parameter&>::type raw(raw_sexp); + return Rcpp::wrap(io___CompressedInputStream__Make(codec, raw)); +END_RCPP } #else SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___CompressedInputStream__Make(). "); } #endif +// compute.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr compute___CastOptions__initialize(bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate); SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type allow_int_overflow(allow_int_overflow_sexp); -Rcpp::traits::input_parameter::type allow_time_truncate(allow_time_truncate_sexp); -Rcpp::traits::input_parameter::type allow_float_truncate(allow_float_truncate_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(compute___CastOptions__initialize( allow_int_overflow, allow_time_truncate, allow_float_truncate))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type allow_int_overflow(allow_int_overflow_sexp); + Rcpp::traits::input_parameter::type allow_time_truncate(allow_time_truncate_sexp); + Rcpp::traits::input_parameter::type allow_float_truncate(allow_float_truncate_sexp); + return Rcpp::wrap(compute___CastOptions__initialize(allow_int_overflow, allow_time_truncate, allow_float_truncate)); +END_RCPP } #else SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call compute___CastOptions__initialize(). "); } #endif +// compute.cpp:32 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__cast(const std::shared_ptr& array, const std::shared_ptr& target_type, const std::shared_ptr& options); SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type array(array_sexp); -Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); -Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Array__cast( array, target_type, options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type array(array_sexp); + Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); + Rcpp::traits::input_parameter&>::type options(options_sexp); + return Rcpp::wrap(Array__cast(array, target_type, options)); +END_RCPP } #else SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Array__cast(). "); } #endif +// compute.cpp:43 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__cast(const std::shared_ptr& chunked_array, const std::shared_ptr& target_type, const std::shared_ptr& options); SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); -Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); -Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ChunkedArray__cast( chunked_array, target_type, options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); + Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); + Rcpp::traits::input_parameter&>::type options(options_sexp); + return Rcpp::wrap(ChunkedArray__cast(chunked_array, target_type, options)); +END_RCPP } #else SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ChunkedArray__cast(). "); } #endif +// compute.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__cast(const std::shared_ptr& batch, const std::shared_ptr& schema, const std::shared_ptr& options); SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp); -Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__cast( batch, schema, options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + Rcpp::traits::input_parameter&>::type options(options_sexp); + return Rcpp::wrap(RecordBatch__cast(batch, schema, options)); +END_RCPP } #else SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__cast(). "); } #endif +// compute.cpp:70 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__cast(const std::shared_ptr& table, const std::shared_ptr& schema, const std::shared_ptr& options); SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type table(table_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp); -Rcpp::traits::input_parameter&>::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__cast( table, schema, options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + Rcpp::traits::input_parameter&>::type options(options_sexp); + return Rcpp::wrap(Table__cast(table, schema, options)); +END_RCPP } #else SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__cast(). "); } #endif +// csv.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ReadOptions__initialize(List_ options); SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ReadOptions__initialize( options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp); + return Rcpp::wrap(csv___ReadOptions__initialize(options)); +END_RCPP } #else SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call csv___ReadOptions__initialize(). "); } #endif +// csv.cpp:36 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ParseOptions__initialize(List_ options); SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ParseOptions__initialize( options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp); + return Rcpp::wrap(csv___ParseOptions__initialize(options)); +END_RCPP } #else SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call csv___ParseOptions__initialize(). "); } #endif +// csv.cpp:51 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ConvertOptions__initialize(List_ options); SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type options(options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___ConvertOptions__initialize( options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type options(options_sexp); + return Rcpp::wrap(csv___ConvertOptions__initialize(options)); +END_RCPP } #else SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call csv___ConvertOptions__initialize(). "); } #endif +// csv.cpp:60 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___TableReader__Make(const std::shared_ptr& input, const std::shared_ptr& read_options, const std::shared_ptr& parse_options, const std::shared_ptr& convert_options); SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type input(input_sexp); -Rcpp::traits::input_parameter&>::type read_options(read_options_sexp); -Rcpp::traits::input_parameter&>::type parse_options(parse_options_sexp); -Rcpp::traits::input_parameter&>::type convert_options(convert_options_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___TableReader__Make( input, read_options, parse_options, convert_options))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type input(input_sexp); + Rcpp::traits::input_parameter&>::type read_options(read_options_sexp); + Rcpp::traits::input_parameter&>::type parse_options(parse_options_sexp); + Rcpp::traits::input_parameter&>::type convert_options(convert_options_sexp); + return Rcpp::wrap(csv___TableReader__Make(input, read_options, parse_options, convert_options)); +END_RCPP } #else SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Make(). "); } #endif +// csv.cpp:73 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___TableReader__Read(const std::shared_ptr& table_reader); SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type table_reader(table_reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(csv___TableReader__Read( table_reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table_reader(table_reader_sexp); + return Rcpp::wrap(csv___TableReader__Read(table_reader)); +END_RCPP } #else SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Read(). "); } #endif +// datatype.cpp:27 #if defined(ARROW_R_WITH_ARROW) bool shared_ptr_is_null(SEXP xp); SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type xp(xp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(shared_ptr_is_null( xp))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type xp(xp_sexp); + return Rcpp::wrap(shared_ptr_is_null(xp)); +END_RCPP } #else SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call shared_ptr_is_null(). "); } #endif +// datatype.cpp:32 #if defined(ARROW_R_WITH_ARROW) bool unique_ptr_is_null(SEXP xp); SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type xp(xp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(unique_ptr_is_null( xp))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type xp(xp_sexp); + return Rcpp::wrap(unique_ptr_is_null(xp)); +END_RCPP } #else SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call unique_ptr_is_null(). "); } #endif +// datatype.cpp:37 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int8__initialize(); SEXP _arrow_Int8__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int8__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Int8__initialize()); +END_RCPP } #else SEXP _arrow_Int8__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Int8__initialize(). "); } #endif +// datatype.cpp:40 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int16__initialize(); SEXP _arrow_Int16__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int16__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Int16__initialize()); +END_RCPP } #else SEXP _arrow_Int16__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Int16__initialize(). "); } #endif +// datatype.cpp:43 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int32__initialize(); SEXP _arrow_Int32__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int32__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Int32__initialize()); +END_RCPP } #else SEXP _arrow_Int32__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Int32__initialize(). "); } #endif +// datatype.cpp:46 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int64__initialize(); SEXP _arrow_Int64__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Int64__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Int64__initialize()); +END_RCPP } #else SEXP _arrow_Int64__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Int64__initialize(). "); } #endif +// datatype.cpp:49 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt8__initialize(); SEXP _arrow_UInt8__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt8__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(UInt8__initialize()); +END_RCPP } #else SEXP _arrow_UInt8__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call UInt8__initialize(). "); } #endif +// datatype.cpp:52 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt16__initialize(); SEXP _arrow_UInt16__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt16__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(UInt16__initialize()); +END_RCPP } #else SEXP _arrow_UInt16__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call UInt16__initialize(). "); } #endif +// datatype.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt32__initialize(); SEXP _arrow_UInt32__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt32__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(UInt32__initialize()); +END_RCPP } #else SEXP _arrow_UInt32__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call UInt32__initialize(). "); } #endif +// datatype.cpp:58 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt64__initialize(); SEXP _arrow_UInt64__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(UInt64__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(UInt64__initialize()); +END_RCPP } #else SEXP _arrow_UInt64__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call UInt64__initialize(). "); } #endif +// datatype.cpp:61 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float16__initialize(); SEXP _arrow_Float16__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float16__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Float16__initialize()); +END_RCPP } #else SEXP _arrow_Float16__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Float16__initialize(). "); } #endif +// datatype.cpp:64 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float32__initialize(); SEXP _arrow_Float32__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float32__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Float32__initialize()); +END_RCPP } #else SEXP _arrow_Float32__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Float32__initialize(). "); } #endif +// datatype.cpp:67 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float64__initialize(); SEXP _arrow_Float64__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Float64__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Float64__initialize()); +END_RCPP } #else SEXP _arrow_Float64__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Float64__initialize(). "); } #endif +// datatype.cpp:70 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Boolean__initialize(); SEXP _arrow_Boolean__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Boolean__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Boolean__initialize()); +END_RCPP } #else SEXP _arrow_Boolean__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Boolean__initialize(). "); } #endif +// datatype.cpp:73 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Utf8__initialize(); SEXP _arrow_Utf8__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Utf8__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Utf8__initialize()); +END_RCPP } #else SEXP _arrow_Utf8__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Utf8__initialize(). "); } #endif +// datatype.cpp:76 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Date32__initialize(); SEXP _arrow_Date32__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Date32__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Date32__initialize()); +END_RCPP } #else SEXP _arrow_Date32__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Date32__initialize(). "); } #endif +// datatype.cpp:79 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Date64__initialize(); SEXP _arrow_Date64__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Date64__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Date64__initialize()); +END_RCPP } #else SEXP _arrow_Date64__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Date64__initialize(). "); } #endif +// datatype.cpp:82 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Null__initialize(); SEXP _arrow_Null__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Null__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(Null__initialize()); +END_RCPP } #else SEXP _arrow_Null__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Null__initialize(). "); } #endif +// datatype.cpp:85 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Decimal128Type__initialize(int32_t precision, int32_t scale); SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type precision(precision_sexp); -Rcpp::traits::input_parameter::type scale(scale_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Decimal128Type__initialize( precision, scale))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type precision(precision_sexp); + Rcpp::traits::input_parameter::type scale(scale_sexp); + return Rcpp::wrap(Decimal128Type__initialize(precision, scale)); +END_RCPP } #else SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Decimal128Type__initialize(). "); } #endif +// datatype.cpp:91 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr FixedSizeBinary__initialize(int32_t byte_width); SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type byte_width(byte_width_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(FixedSizeBinary__initialize( byte_width))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type byte_width(byte_width_sexp); + return Rcpp::wrap(FixedSizeBinary__initialize(byte_width)); +END_RCPP } #else SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call FixedSizeBinary__initialize(). "); } #endif +// datatype.cpp:96 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Timestamp__initialize1(arrow::TimeUnit::type unit); SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Timestamp__initialize1( unit))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp); + return Rcpp::wrap(Timestamp__initialize1(unit)); +END_RCPP } #else SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize1(). "); } #endif +// datatype.cpp:101 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Timestamp__initialize2(arrow::TimeUnit::type unit, const std::string& timezone); SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type unit(unit_sexp); -Rcpp::traits::input_parameter::type timezone(timezone_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Timestamp__initialize2( unit, timezone))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp); + Rcpp::traits::input_parameter::type timezone(timezone_sexp); + return Rcpp::wrap(Timestamp__initialize2(unit, timezone)); +END_RCPP } #else SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize2(). "); } #endif +// datatype.cpp:107 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Time32__initialize(arrow::TimeUnit::type unit); SEXP _arrow_Time32__initialize(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Time32__initialize( unit))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp); + return Rcpp::wrap(Time32__initialize(unit)); +END_RCPP } #else SEXP _arrow_Time32__initialize(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Time32__initialize(). "); } #endif +// datatype.cpp:112 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Time64__initialize(arrow::TimeUnit::type unit); SEXP _arrow_Time64__initialize(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type unit(unit_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Time64__initialize( unit))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type unit(unit_sexp); + return Rcpp::wrap(Time64__initialize(unit)); +END_RCPP } #else SEXP _arrow_Time64__initialize(SEXP unit_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Time64__initialize(). "); } #endif +// datatype.cpp:117 #if defined(ARROW_R_WITH_ARROW) SEXP list__(SEXP x); SEXP _arrow_list__(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(list__( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type x(x_sexp); + return Rcpp::wrap(list__(x)); +END_RCPP } #else SEXP _arrow_list__(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call list__(). "); } #endif +// datatype.cpp:133 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr struct_(List fields); SEXP _arrow_struct_(SEXP fields_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type fields(fields_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(struct_( fields))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type fields(fields_sexp); + return Rcpp::wrap(struct_(fields)); +END_RCPP } #else SEXP _arrow_struct_(SEXP fields_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call struct_(). "); } #endif +// datatype.cpp:138 #if defined(ARROW_R_WITH_ARROW) std::string DataType__ToString(const std::shared_ptr& type); SEXP _arrow_DataType__ToString(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__ToString( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DataType__ToString(type)); +END_RCPP } #else SEXP _arrow_DataType__ToString(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__ToString(). "); } #endif +// datatype.cpp:143 #if defined(ARROW_R_WITH_ARROW) std::string DataType__name(const std::shared_ptr& type); SEXP _arrow_DataType__name(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__name( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DataType__name(type)); +END_RCPP } #else SEXP _arrow_DataType__name(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__name(). "); } #endif +// datatype.cpp:148 #if defined(ARROW_R_WITH_ARROW) bool DataType__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); -Rcpp::traits::input_parameter&>::type rhs(rhs_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__Equals( lhs, rhs))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); + Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); + return Rcpp::wrap(DataType__Equals(lhs, rhs)); +END_RCPP } #else SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__Equals(). "); } #endif +// datatype.cpp:154 #if defined(ARROW_R_WITH_ARROW) int DataType__num_children(const std::shared_ptr& type); SEXP _arrow_DataType__num_children(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__num_children( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DataType__num_children(type)); +END_RCPP } #else SEXP _arrow_DataType__num_children(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__num_children(). "); } #endif +// datatype.cpp:159 #if defined(ARROW_R_WITH_ARROW) List DataType__children_pointer(const std::shared_ptr& type); SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__children_pointer( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DataType__children_pointer(type)); +END_RCPP } #else SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__children_pointer(). "); } #endif +// datatype.cpp:164 #if defined(ARROW_R_WITH_ARROW) arrow::Type::type DataType__id(const std::shared_ptr& type); SEXP _arrow_DataType__id(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DataType__id( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DataType__id(type)); +END_RCPP } #else SEXP _arrow_DataType__id(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DataType__id(). "); } #endif +// datatype.cpp:169 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr schema_(List fields); SEXP _arrow_schema_(SEXP fields_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type fields(fields_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(schema_( fields))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type fields(fields_sexp); + return Rcpp::wrap(schema_(fields)); +END_RCPP } #else SEXP _arrow_schema_(SEXP fields_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call schema_(). "); } #endif +// datatype.cpp:174 #if defined(ARROW_R_WITH_ARROW) std::string Schema__ToString(const std::shared_ptr& s); SEXP _arrow_Schema__ToString(SEXP s_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type s(s_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__ToString( s))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp); + return Rcpp::wrap(Schema__ToString(s)); +END_RCPP } #else SEXP _arrow_Schema__ToString(SEXP s_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Schema__ToString(). "); } #endif +// datatype.cpp:179 #if defined(ARROW_R_WITH_ARROW) int Schema__num_fields(const std::shared_ptr& s); SEXP _arrow_Schema__num_fields(SEXP s_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type s(s_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__num_fields( s))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp); + return Rcpp::wrap(Schema__num_fields(s)); +END_RCPP } #else SEXP _arrow_Schema__num_fields(SEXP s_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Schema__num_fields(). "); } #endif +// datatype.cpp:184 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Schema__field(const std::shared_ptr& s, int i); SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type s(s_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__field( s, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type s(s_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(Schema__field(s, i)); +END_RCPP } #else SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Schema__field(). "); } #endif +// datatype.cpp:194 #if defined(ARROW_R_WITH_ARROW) CharacterVector Schema__names(const std::shared_ptr& schema); SEXP _arrow_Schema__names(SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Schema__names( schema))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + return Rcpp::wrap(Schema__names(schema)); +END_RCPP } #else SEXP _arrow_Schema__names(SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Schema__names(). "); } #endif +// datatype.cpp:202 #if defined(ARROW_R_WITH_ARROW) std::string ListType__ToString(const std::shared_ptr& type); SEXP _arrow_ListType__ToString(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ListType__ToString( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(ListType__ToString(type)); +END_RCPP } #else SEXP _arrow_ListType__ToString(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ListType__ToString(). "); } #endif +// datatype.cpp:207 #if defined(ARROW_R_WITH_ARROW) int FixedWidthType__bit_width(const std::shared_ptr& type); SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(FixedWidthType__bit_width( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(FixedWidthType__bit_width(type)); +END_RCPP } #else SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call FixedWidthType__bit_width(). "); } #endif +// datatype.cpp:212 #if defined(ARROW_R_WITH_ARROW) arrow::DateUnit DateType__unit(const std::shared_ptr& type); SEXP _arrow_DateType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DateType__unit( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DateType__unit(type)); +END_RCPP } #else SEXP _arrow_DateType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DateType__unit(). "); } #endif +// datatype.cpp:217 #if defined(ARROW_R_WITH_ARROW) arrow::TimeUnit::type TimeType__unit(const std::shared_ptr& type); SEXP _arrow_TimeType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimeType__unit( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(TimeType__unit(type)); +END_RCPP } #else SEXP _arrow_TimeType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call TimeType__unit(). "); } #endif +// datatype.cpp:222 #if defined(ARROW_R_WITH_ARROW) int32_t DecimalType__precision(const std::shared_ptr& type); SEXP _arrow_DecimalType__precision(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DecimalType__precision( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DecimalType__precision(type)); +END_RCPP } #else SEXP _arrow_DecimalType__precision(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DecimalType__precision(). "); } #endif +// datatype.cpp:227 #if defined(ARROW_R_WITH_ARROW) int32_t DecimalType__scale(const std::shared_ptr& type); SEXP _arrow_DecimalType__scale(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DecimalType__scale( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DecimalType__scale(type)); +END_RCPP } #else SEXP _arrow_DecimalType__scale(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DecimalType__scale(). "); } #endif +// datatype.cpp:232 #if defined(ARROW_R_WITH_ARROW) std::string TimestampType__timezone(const std::shared_ptr& type); SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimestampType__timezone( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(TimestampType__timezone(type)); +END_RCPP } #else SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call TimestampType__timezone(). "); } #endif +// datatype.cpp:237 #if defined(ARROW_R_WITH_ARROW) arrow::TimeUnit::type TimestampType__unit(const std::shared_ptr& type); SEXP _arrow_TimestampType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(TimestampType__unit( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(TimestampType__unit(type)); +END_RCPP } #else SEXP _arrow_TimestampType__unit(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call TimestampType__unit(). "); } #endif +// datatype.cpp:243 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__initialize(const std::shared_ptr& index_type, const std::shared_ptr& value_type, bool ordered); SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type index_type(index_type_sexp); -Rcpp::traits::input_parameter&>::type value_type(value_type_sexp); -Rcpp::traits::input_parameter::type ordered(ordered_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__initialize( index_type, value_type, ordered))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type index_type(index_type_sexp); + Rcpp::traits::input_parameter&>::type value_type(value_type_sexp); + Rcpp::traits::input_parameter::type ordered(ordered_sexp); + return Rcpp::wrap(DictionaryType__initialize(index_type, value_type, ordered)); +END_RCPP } #else SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryType__initialize(). "); } #endif +// datatype.cpp:250 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__index_type(const std::shared_ptr& type); SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__index_type( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DictionaryType__index_type(type)); +END_RCPP } #else SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryType__index_type(). "); } #endif +// datatype.cpp:256 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__value_type(const std::shared_ptr& type); SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__value_type( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DictionaryType__value_type(type)); +END_RCPP } #else SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryType__value_type(). "); } #endif +// datatype.cpp:262 #if defined(ARROW_R_WITH_ARROW) std::string DictionaryType__name(const std::shared_ptr& type); SEXP _arrow_DictionaryType__name(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__name( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DictionaryType__name(type)); +END_RCPP } #else SEXP _arrow_DictionaryType__name(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryType__name(). "); } #endif +// datatype.cpp:267 #if defined(ARROW_R_WITH_ARROW) bool DictionaryType__ordered(const std::shared_ptr& type); SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type type(type_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(DictionaryType__ordered( type))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type type(type_sexp); + return Rcpp::wrap(DictionaryType__ordered(type)); +END_RCPP } #else SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call DictionaryType__ordered(). "); } #endif +// feather.cpp:24 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__SetDescription(const std::unique_ptr& writer, const std::string& description); SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type writer(writer_sexp); -Rcpp::traits::input_parameter::type description(description_sexp);ipc___feather___TableWriter__SetDescription( writer, description); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); + Rcpp::traits::input_parameter::type description(description_sexp); + ipc___feather___TableWriter__SetDescription(writer, description); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetDescription(). "); } #endif +// feather.cpp:31 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__SetNumRows(const std::unique_ptr& writer, int64_t num_rows); SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type writer(writer_sexp); -Rcpp::traits::input_parameter::type num_rows(num_rows_sexp);ipc___feather___TableWriter__SetNumRows( writer, num_rows); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); + Rcpp::traits::input_parameter::type num_rows(num_rows_sexp); + ipc___feather___TableWriter__SetNumRows(writer, num_rows); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetNumRows(). "); } #endif +// feather.cpp:37 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__Append(const std::unique_ptr& writer, const std::string& name, const std::shared_ptr& values); SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type writer(writer_sexp); -Rcpp::traits::input_parameter::type name(name_sexp); -Rcpp::traits::input_parameter&>::type values(values_sexp);ipc___feather___TableWriter__Append( writer, name, values); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); + Rcpp::traits::input_parameter::type name(name_sexp); + Rcpp::traits::input_parameter&>::type values(values_sexp); + ipc___feather___TableWriter__Append(writer, name, values); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Append(). "); } #endif +// feather.cpp:44 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__Finalize(const std::unique_ptr& writer); SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type writer(writer_sexp);ipc___feather___TableWriter__Finalize( writer); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); + ipc___feather___TableWriter__Finalize(writer); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Finalize(). "); } #endif +// feather.cpp:50 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___feather___TableWriter__Open(const std::shared_ptr& stream); SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableWriter__Open( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___feather___TableWriter__Open(stream)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Open(). "); } #endif +// feather.cpp:58 #if defined(ARROW_R_WITH_ARROW) void ipc___TableWriter__RecordBatch__WriteFeather(const std::unique_ptr& writer, const std::shared_ptr& batch); SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type writer(writer_sexp); -Rcpp::traits::input_parameter&>::type batch(batch_sexp);ipc___TableWriter__RecordBatch__WriteFeather( writer, batch); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type writer(writer_sexp); + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + ipc___TableWriter__RecordBatch__WriteFeather(writer, batch); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___TableWriter__RecordBatch__WriteFeather(). "); } #endif +// feather.cpp:72 #if defined(ARROW_R_WITH_ARROW) std::string ipc___feather___TableReader__GetDescription(const std::unique_ptr& reader); SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetDescription( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___feather___TableReader__GetDescription(reader)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetDescription(). "); } #endif +// feather.cpp:78 #if defined(ARROW_R_WITH_ARROW) bool ipc___feather___TableReader__HasDescription(const std::unique_ptr& reader); SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__HasDescription( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___feather___TableReader__HasDescription(reader)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__HasDescription(). "); } #endif +// feather.cpp:84 #if defined(ARROW_R_WITH_ARROW) int ipc___feather___TableReader__version(const std::unique_ptr& reader); SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__version( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___feather___TableReader__version(reader)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__version(). "); } #endif +// feather.cpp:90 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___feather___TableReader__num_rows(const std::unique_ptr& reader); SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__num_rows( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___feather___TableReader__num_rows(reader)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_rows(). "); } #endif +// feather.cpp:96 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___feather___TableReader__num_columns(const std::unique_ptr& reader); SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__num_columns( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___feather___TableReader__num_columns(reader)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_columns(). "); } #endif +// feather.cpp:102 #if defined(ARROW_R_WITH_ARROW) std::string ipc___feather___TableReader__GetColumnName(const std::unique_ptr& reader, int i); SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetColumnName( reader, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(ipc___feather___TableReader__GetColumnName(reader, i)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumnName(). "); } #endif +// feather.cpp:108 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___feather___TableReader__GetColumn(const std::unique_ptr& reader, int i); SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__GetColumn( reader, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(ipc___feather___TableReader__GetColumn(reader, i)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumn(). "); } #endif +// feather.cpp:116 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___feather___TableReader__Read(const std::unique_ptr& reader, SEXP columns); SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp); -Rcpp::traits::input_parameter::type columns(columns_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__Read( reader, columns))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + Rcpp::traits::input_parameter::type columns(columns_sexp); + return Rcpp::wrap(ipc___feather___TableReader__Read(reader, columns)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Read(). "); } #endif +// feather.cpp:152 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___feather___TableReader__Open(const std::shared_ptr& stream); SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___feather___TableReader__Open( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___feather___TableReader__Open(stream)); +END_RCPP } #else SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Open(). "); } #endif +// field.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Field__initialize(const std::string& name, const std::shared_ptr& field, bool nullable); SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type name(name_sexp); -Rcpp::traits::input_parameter&>::type field(field_sexp); -Rcpp::traits::input_parameter::type nullable(nullable_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__initialize( name, field, nullable))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type name(name_sexp); + Rcpp::traits::input_parameter&>::type field(field_sexp); + Rcpp::traits::input_parameter::type nullable(nullable_sexp); + return Rcpp::wrap(Field__initialize(name, field, nullable)); +END_RCPP } #else SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__initialize(). "); } #endif +// field.cpp:29 #if defined(ARROW_R_WITH_ARROW) std::string Field__ToString(const std::shared_ptr& field); SEXP _arrow_Field__ToString(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__ToString( field))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); + return Rcpp::wrap(Field__ToString(field)); +END_RCPP } #else SEXP _arrow_Field__ToString(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__ToString(). "); } #endif +// field.cpp:34 #if defined(ARROW_R_WITH_ARROW) std::string Field__name(const std::shared_ptr& field); SEXP _arrow_Field__name(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__name( field))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); + return Rcpp::wrap(Field__name(field)); +END_RCPP } #else SEXP _arrow_Field__name(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__name(). "); } #endif +// field.cpp:39 #if defined(ARROW_R_WITH_ARROW) bool Field__Equals(const std::shared_ptr& field, const std::shared_ptr& other); SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type field(field_sexp); -Rcpp::traits::input_parameter&>::type other(other_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__Equals( field, other))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); + Rcpp::traits::input_parameter&>::type other(other_sexp); + return Rcpp::wrap(Field__Equals(field, other)); +END_RCPP } #else SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__Equals(). "); } #endif +// field.cpp:45 #if defined(ARROW_R_WITH_ARROW) bool Field__nullable(const std::shared_ptr& field); SEXP _arrow_Field__nullable(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__nullable( field))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); + return Rcpp::wrap(Field__nullable(field)); +END_RCPP } #else SEXP _arrow_Field__nullable(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__nullable(). "); } #endif +// field.cpp:50 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Field__type(const std::shared_ptr& field); SEXP _arrow_Field__type(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type field(field_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Field__type( field))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type field(field_sexp); + return Rcpp::wrap(Field__type(field)); +END_RCPP } #else SEXP _arrow_Field__type(SEXP field_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Field__type(). "); } #endif +// io.cpp:26 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___Readable__Read(const std::shared_ptr& x, int64_t nbytes); SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter::type nbytes(nbytes_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___Readable__Read( x, nbytes))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter::type nbytes(nbytes_sexp); + return Rcpp::wrap(io___Readable__Read(x, nbytes)); +END_RCPP } #else SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___Readable__Read(). "); } #endif +// io.cpp:36 #if defined(ARROW_R_WITH_ARROW) void io___InputStream__Close(const std::shared_ptr& x); SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);io___InputStream__Close( x); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + io___InputStream__Close(x); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___InputStream__Close(). "); } #endif +// io.cpp:43 #if defined(ARROW_R_WITH_ARROW) void io___OutputStream__Close(const std::shared_ptr& x); SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);io___OutputStream__Close( x); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + io___OutputStream__Close(x); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Close(). "); } #endif +// io.cpp:50 #if defined(ARROW_R_WITH_ARROW) int64_t io___RandomAccessFile__GetSize(const std::shared_ptr& x); SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__GetSize( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(io___RandomAccessFile__GetSize(x)); +END_RCPP } #else SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__GetSize(). "); } #endif +// io.cpp:58 #if defined(ARROW_R_WITH_ARROW) bool io___RandomAccessFile__supports_zero_copy(const std::shared_ptr& x); SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__supports_zero_copy( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(io___RandomAccessFile__supports_zero_copy(x)); +END_RCPP } #else SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__supports_zero_copy(). "); } #endif +// io.cpp:64 #if defined(ARROW_R_WITH_ARROW) void io___RandomAccessFile__Seek(const std::shared_ptr& x, int64_t position); SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter::type position(position_sexp);io___RandomAccessFile__Seek( x, position); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter::type position(position_sexp); + io___RandomAccessFile__Seek(x, position); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Seek(). "); } #endif +// io.cpp:70 #if defined(ARROW_R_WITH_ARROW) int64_t io___RandomAccessFile__Tell(const std::shared_ptr& x); SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___RandomAccessFile__Tell( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(io___RandomAccessFile__Tell(x)); +END_RCPP } #else SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Tell(). "); } #endif +// io.cpp:80 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MemoryMappedFile__Create(const std::string& path, int64_t size); SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type path(path_sexp); -Rcpp::traits::input_parameter::type size(size_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MemoryMappedFile__Create( path, size))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); + Rcpp::traits::input_parameter::type size(size_sexp); + return Rcpp::wrap(io___MemoryMappedFile__Create(path, size)); +END_RCPP } #else SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Create(). "); } #endif +// io.cpp:88 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MemoryMappedFile__Open(const std::string& path, arrow::io::FileMode::type mode); SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type path(path_sexp); -Rcpp::traits::input_parameter::type mode(mode_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MemoryMappedFile__Open( path, mode))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); + Rcpp::traits::input_parameter::type mode(mode_sexp); + return Rcpp::wrap(io___MemoryMappedFile__Open(path, mode)); +END_RCPP } #else SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Open(). "); } #endif +// io.cpp:96 #if defined(ARROW_R_WITH_ARROW) void io___MemoryMappedFile__Resize(const std::shared_ptr& x, int64_t size); SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter::type size(size_sexp);io___MemoryMappedFile__Resize( x, size); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter::type size(size_sexp); + io___MemoryMappedFile__Resize(x, size); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Resize(). "); } #endif +// io.cpp:104 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___ReadableFile__Open(const std::string& path); SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type path(path_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___ReadableFile__Open( path))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); + return Rcpp::wrap(io___ReadableFile__Open(path)); +END_RCPP } #else SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___ReadableFile__Open(). "); } #endif +// io.cpp:114 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferReader__initialize(const std::shared_ptr& buffer); SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferReader__initialize( buffer))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + return Rcpp::wrap(io___BufferReader__initialize(buffer)); +END_RCPP } #else SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferReader__initialize(). "); } #endif +// io.cpp:122 #if defined(ARROW_R_WITH_ARROW) void io___Writable__write(const std::shared_ptr& stream, const std::shared_ptr& buf); SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp); -Rcpp::traits::input_parameter&>::type buf(buf_sexp);io___Writable__write( stream, buf); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + Rcpp::traits::input_parameter&>::type buf(buf_sexp); + io___Writable__write(stream, buf); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___Writable__write(). "); } #endif +// io.cpp:130 #if defined(ARROW_R_WITH_ARROW) int64_t io___OutputStream__Tell(const std::shared_ptr& stream); SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___OutputStream__Tell( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(io___OutputStream__Tell(stream)); +END_RCPP } #else SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Tell(). "); } #endif +// io.cpp:139 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___FileOutputStream__Open(const std::string& path); SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type path(path_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___FileOutputStream__Open( path))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type path(path_sexp); + return Rcpp::wrap(io___FileOutputStream__Open(path)); +END_RCPP } #else SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___FileOutputStream__Open(). "); } #endif +// io.cpp:149 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferOutputStream__Create(int64_t initial_capacity); SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type initial_capacity(initial_capacity_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Create( initial_capacity))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type initial_capacity(initial_capacity_sexp); + return Rcpp::wrap(io___BufferOutputStream__Create(initial_capacity)); +END_RCPP } #else SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Create(). "); } #endif +// io.cpp:158 #if defined(ARROW_R_WITH_ARROW) int64_t io___BufferOutputStream__capacity(const std::shared_ptr& stream); SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__capacity( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(io___BufferOutputStream__capacity(stream)); +END_RCPP } #else SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__capacity(). "); } #endif +// io.cpp:164 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferOutputStream__Finish(const std::shared_ptr& stream); SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Finish( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(io___BufferOutputStream__Finish(stream)); +END_RCPP } #else SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Finish(). "); } #endif +// io.cpp:172 #if defined(ARROW_R_WITH_ARROW) int64_t io___BufferOutputStream__Tell(const std::shared_ptr& stream); SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___BufferOutputStream__Tell( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(io___BufferOutputStream__Tell(stream)); +END_RCPP } #else SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Tell(). "); } #endif +// io.cpp:180 #if defined(ARROW_R_WITH_ARROW) void io___BufferOutputStream__Write(const std::shared_ptr& stream, RawVector_ bytes); SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp); -Rcpp::traits::input_parameter::type bytes(bytes_sexp);io___BufferOutputStream__Write( stream, bytes); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + Rcpp::traits::input_parameter::type bytes(bytes_sexp); + io___BufferOutputStream__Write(stream, bytes); + return R_NilValue; +END_RCPP } #else SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Write(). "); } #endif +// io.cpp:188 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MockOutputStream__initialize(); SEXP _arrow_io___MockOutputStream__initialize(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MockOutputStream__initialize( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(io___MockOutputStream__initialize()); +END_RCPP } #else SEXP _arrow_io___MockOutputStream__initialize(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__initialize(). "); } #endif +// io.cpp:193 #if defined(ARROW_R_WITH_ARROW) int64_t io___MockOutputStream__GetExtentBytesWritten(const std::shared_ptr& stream); SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___MockOutputStream__GetExtentBytesWritten( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(io___MockOutputStream__GetExtentBytesWritten(stream)); +END_RCPP } #else SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__GetExtentBytesWritten(). "); } #endif +// io.cpp:201 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___FixedSizeBufferWriter__initialize(const std::shared_ptr& buffer); SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type buffer(buffer_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(io___FixedSizeBufferWriter__initialize( buffer))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); + return Rcpp::wrap(io___FixedSizeBufferWriter__initialize(buffer)); +END_RCPP } #else SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call io___FixedSizeBufferWriter__initialize(). "); } #endif +// memorypool.cpp:21 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr MemoryPool__default(); SEXP _arrow_MemoryPool__default(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__default( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(MemoryPool__default()); +END_RCPP } #else SEXP _arrow_MemoryPool__default(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call MemoryPool__default(). "); } #endif +// memorypool.cpp:27 #if defined(ARROW_R_WITH_ARROW) int MemoryPool__bytes_allocated(const std::shared_ptr& pool); SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type pool(pool_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__bytes_allocated( pool))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type pool(pool_sexp); + return Rcpp::wrap(MemoryPool__bytes_allocated(pool)); +END_RCPP } #else SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call MemoryPool__bytes_allocated(). "); } #endif +// memorypool.cpp:32 #if defined(ARROW_R_WITH_ARROW) int MemoryPool__max_memory(const std::shared_ptr& pool); SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type pool(pool_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(MemoryPool__max_memory( pool))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type pool(pool_sexp); + return Rcpp::wrap(MemoryPool__max_memory(pool)); +END_RCPP } #else SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call MemoryPool__max_memory(). "); } #endif +// message.cpp:22 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___Message__body_length(const std::unique_ptr& message); SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__body_length( message))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + return Rcpp::wrap(ipc___Message__body_length(message)); +END_RCPP } #else SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__body_length(). "); } #endif +// message.cpp:27 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___Message__metadata(const std::unique_ptr& message); SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__metadata( message))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + return Rcpp::wrap(ipc___Message__metadata(message)); +END_RCPP } #else SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__metadata(). "); } #endif +// message.cpp:33 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___Message__body(const std::unique_ptr& message); SEXP _arrow_ipc___Message__body(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__body( message))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + return Rcpp::wrap(ipc___Message__body(message)); +END_RCPP } #else SEXP _arrow_ipc___Message__body(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__body(). "); } #endif +// message.cpp:39 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___Message__Verify(const std::unique_ptr& message); SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__Verify( message))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + return Rcpp::wrap(ipc___Message__Verify(message)); +END_RCPP } #else SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__Verify(). "); } #endif +// message.cpp:44 #if defined(ARROW_R_WITH_ARROW) arrow::ipc::Message::Type ipc___Message__type(const std::unique_ptr& message); SEXP _arrow_ipc___Message__type(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__type( message))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + return Rcpp::wrap(ipc___Message__type(message)); +END_RCPP } #else SEXP _arrow_ipc___Message__type(SEXP message_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__type(). "); } #endif +// message.cpp:50 #if defined(ARROW_R_WITH_ARROW) bool ipc___Message__Equals(const std::unique_ptr& x, const std::unique_ptr& y); SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp); -Rcpp::traits::input_parameter&>::type y(y_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___Message__Equals( x, y))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + Rcpp::traits::input_parameter&>::type y(y_sexp); + return Rcpp::wrap(ipc___Message__Equals(x, y)); +END_RCPP } #else SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___Message__Equals(). "); } #endif +// message.cpp:56 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadRecordBatch__Message__Schema(const std::unique_ptr& message, const std::shared_ptr& schema); SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type message(message_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadRecordBatch__Message__Schema( message, schema))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type message(message_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + return Rcpp::wrap(ipc___ReadRecordBatch__Message__Schema(message, schema)); +END_RCPP } #else SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__Message__Schema(). "); } #endif +// message.cpp:68 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadSchema_InputStream(const std::shared_ptr& stream); SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadSchema_InputStream( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___ReadSchema_InputStream(stream)); +END_RCPP } #else SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___ReadSchema_InputStream(). "); } #endif +// message.cpp:80 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___MessageReader__Open(const std::shared_ptr& stream); SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___MessageReader__Open( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___MessageReader__Open(stream)); +END_RCPP } #else SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__Open(). "); } #endif +// message.cpp:86 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___MessageReader__ReadNextMessage(const std::unique_ptr& reader); SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___MessageReader__ReadNextMessage( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___MessageReader__ReadNextMessage(reader)); +END_RCPP } #else SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__ReadNextMessage(). "); } #endif +// message.cpp:94 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___ReadMessage(const std::shared_ptr& stream); SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadMessage( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___ReadMessage(stream)); +END_RCPP } #else SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___ReadMessage(). "); } #endif +// parquet.cpp:29 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr read_parquet_file(std::string filename); SEXP _arrow_read_parquet_file(SEXP filename_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type filename(filename_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(read_parquet_file( filename))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type filename(filename_sexp); + return Rcpp::wrap(read_parquet_file(filename)); +END_RCPP } #else SEXP _arrow_read_parquet_file(SEXP filename_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call read_parquet_file(). "); } #endif +// recordbatch.cpp:26 #if defined(ARROW_R_WITH_ARROW) int RecordBatch__num_columns(const std::shared_ptr& x); SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__num_columns( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(RecordBatch__num_columns(x)); +END_RCPP } #else SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_columns(). "); } #endif +// recordbatch.cpp:31 #if defined(ARROW_R_WITH_ARROW) int RecordBatch__num_rows(const std::shared_ptr& x); SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__num_rows( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(RecordBatch__num_rows(x)); +END_RCPP } #else SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_rows(). "); } #endif +// recordbatch.cpp:36 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__schema(const std::shared_ptr& x); SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__schema( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(RecordBatch__schema(x)); +END_RCPP } #else SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__schema(). "); } #endif +// recordbatch.cpp:42 #if defined(ARROW_R_WITH_ARROW) arrow::ArrayVector RecordBatch__columns(const std::shared_ptr& batch); SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__columns( batch))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + return Rcpp::wrap(RecordBatch__columns(batch)); +END_RCPP } #else SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__columns(). "); } #endif +// recordbatch.cpp:53 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__column(const std::shared_ptr& batch, int i); SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__column( batch, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(RecordBatch__column(batch, i)); +END_RCPP } #else SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__column(). "); } #endif +// recordbatch.cpp:59 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl); SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type tbl(tbl_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__from_dataframe( tbl))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type tbl(tbl_sexp); + return Rcpp::wrap(RecordBatch__from_dataframe(tbl)); +END_RCPP } #else SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_dataframe(). "); } #endif +// recordbatch.cpp:77 #if defined(ARROW_R_WITH_ARROW) bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other); SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type self(self_sexp); -Rcpp::traits::input_parameter&>::type other(other_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Equals( self, other))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); + Rcpp::traits::input_parameter&>::type other(other_sexp); + return Rcpp::wrap(RecordBatch__Equals(self, other)); +END_RCPP } #else SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__Equals(). "); } #endif +// recordbatch.cpp:83 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__RemoveColumn(const std::shared_ptr& batch, int i); SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__RemoveColumn( batch, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(RecordBatch__RemoveColumn(batch, i)); +END_RCPP } #else SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__RemoveColumn(). "); } #endif +// recordbatch.cpp:91 #if defined(ARROW_R_WITH_ARROW) std::string RecordBatch__column_name(const std::shared_ptr& batch, int i); SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__column_name( batch, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(RecordBatch__column_name(batch, i)); +END_RCPP } #else SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__column_name(). "); } #endif +// recordbatch.cpp:97 #if defined(ARROW_R_WITH_ARROW) Rcpp::CharacterVector RecordBatch__names(const std::shared_ptr& batch); SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__names( batch))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + return Rcpp::wrap(RecordBatch__names(batch)); +END_RCPP } #else SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__names(). "); } #endif +// recordbatch.cpp:108 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__Slice1(const std::shared_ptr& self, int offset); SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type self(self_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Slice1( self, offset))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + return Rcpp::wrap(RecordBatch__Slice1(self, offset)); +END_RCPP } #else SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice1(). "); } #endif +// recordbatch.cpp:114 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__Slice2(const std::shared_ptr& self, int offset, int length); SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type self(self_sexp); -Rcpp::traits::input_parameter::type offset(offset_sexp); -Rcpp::traits::input_parameter::type length(length_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__Slice2( self, offset, length))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type self(self_sexp); + Rcpp::traits::input_parameter::type offset(offset_sexp); + Rcpp::traits::input_parameter::type length(length_sexp); + return Rcpp::wrap(RecordBatch__Slice2(self, offset, length)); +END_RCPP } #else SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice2(). "); } #endif +// recordbatch.cpp:120 #if defined(ARROW_R_WITH_ARROW) Rcpp::RawVector ipc___SerializeRecordBatch__Raw(const std::shared_ptr& batch); SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch(batch_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___SerializeRecordBatch__Raw( batch))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + return Rcpp::wrap(ipc___SerializeRecordBatch__Raw(batch)); +END_RCPP } #else SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___SerializeRecordBatch__Raw(). "); } #endif +// recordbatch.cpp:140 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadRecordBatch__InputStream__Schema(const std::shared_ptr& stream, const std::shared_ptr& schema); SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___ReadRecordBatch__InputStream__Schema( stream, schema))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + return Rcpp::wrap(ipc___ReadRecordBatch__InputStream__Schema(stream, schema)); +END_RCPP } #else SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__InputStream__Schema(). "); } #endif +// recordbatch.cpp:189 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst); SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); -Rcpp::traits::input_parameter::type lst(lst_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatch__from_arrays( schema_sxp, lst))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); + Rcpp::traits::input_parameter::type lst(lst_sexp); + return Rcpp::wrap(RecordBatch__from_arrays(schema_sxp, lst)); +END_RCPP } #else SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_arrays(). "); } #endif +// recordbatchreader.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatchReader__schema(const std::shared_ptr& reader); SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatchReader__schema( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(RecordBatchReader__schema(reader)); +END_RCPP } #else SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__schema(). "); } #endif +// recordbatchreader.cpp:28 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatchReader__ReadNext(const std::shared_ptr& reader); SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(RecordBatchReader__ReadNext( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(RecordBatchReader__ReadNext(reader)); +END_RCPP } #else SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__ReadNext(). "); } #endif +// recordbatchreader.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchStreamReader__Open(const std::shared_ptr& stream); SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamReader__Open( stream))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + return Rcpp::wrap(ipc___RecordBatchStreamReader__Open(stream)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__Open(). "); } #endif +// recordbatchreader.cpp:46 #if defined(ARROW_R_WITH_ARROW) std::vector> ipc___RecordBatchStreamReader__batches(const std::shared_ptr& reader); SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamReader__batches( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___RecordBatchStreamReader__batches(reader)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__batches(). "); } #endif +// recordbatchreader.cpp:64 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__schema(const std::shared_ptr& reader); SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__schema( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___RecordBatchFileReader__schema(reader)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__schema(). "); } #endif +// recordbatchreader.cpp:70 #if defined(ARROW_R_WITH_ARROW) int ipc___RecordBatchFileReader__num_record_batches(const std::shared_ptr& reader); SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__num_record_batches( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___RecordBatchFileReader__num_record_batches(reader)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__num_record_batches(). "); } #endif +// recordbatchreader.cpp:76 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch(const std::shared_ptr& reader, int i); SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__ReadRecordBatch( reader, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(ipc___RecordBatchFileReader__ReadRecordBatch(reader, i)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__ReadRecordBatch(). "); } #endif +// recordbatchreader.cpp:86 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__Open(const std::shared_ptr& file); SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type file(file_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__Open( file))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type file(file_sexp); + return Rcpp::wrap(ipc___RecordBatchFileReader__Open(file)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__Open(). "); } #endif +// recordbatchreader.cpp:94 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_RecordBatchFileReader(const std::shared_ptr& reader); SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_RecordBatchFileReader( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(Table__from_RecordBatchFileReader(reader)); +END_RCPP } #else SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchFileReader(). "); } #endif +// recordbatchreader.cpp:109 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_RecordBatchStreamReader(const std::shared_ptr& reader); SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_RecordBatchStreamReader( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(Table__from_RecordBatchStreamReader(reader)); +END_RCPP } #else SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchStreamReader(). "); } #endif +// recordbatchreader.cpp:126 #if defined(ARROW_R_WITH_ARROW) std::vector> ipc___RecordBatchFileReader__batches(const std::shared_ptr& reader); SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type reader(reader_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileReader__batches( reader))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type reader(reader_sexp); + return Rcpp::wrap(ipc___RecordBatchFileReader__batches(reader)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__batches(). "); } #endif +// recordbatchwriter.cpp:22 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__WriteRecordBatch(const std::shared_ptr& batch_writer, const std::shared_ptr& batch); SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); -Rcpp::traits::input_parameter&>::type batch(batch_sexp);ipc___RecordBatchWriter__WriteRecordBatch( batch_writer, batch); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); + Rcpp::traits::input_parameter&>::type batch(batch_sexp); + ipc___RecordBatchWriter__WriteRecordBatch(batch_writer, batch); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteRecordBatch(). "); } #endif +// recordbatchwriter.cpp:29 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__WriteTable(const std::shared_ptr& batch_writer, const std::shared_ptr& table); SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); -Rcpp::traits::input_parameter&>::type table(table_sexp);ipc___RecordBatchWriter__WriteTable( batch_writer, table); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); + Rcpp::traits::input_parameter&>::type table(table_sexp); + ipc___RecordBatchWriter__WriteTable(batch_writer, table); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteTable(). "); } #endif +// recordbatchwriter.cpp:36 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__Close(const std::shared_ptr& batch_writer); SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp);ipc___RecordBatchWriter__Close( batch_writer); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); + ipc___RecordBatchWriter__Close(batch_writer); + return R_NilValue; +END_RCPP } #else SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__Close(). "); } #endif +// recordbatchwriter.cpp:42 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchFileWriter__Open( stream, schema))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + return Rcpp::wrap(ipc___RecordBatchFileWriter__Open(stream, schema)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileWriter__Open(). "); } #endif +// recordbatchwriter.cpp:52 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchStreamWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type stream(stream_sexp); -Rcpp::traits::input_parameter&>::type schema(schema_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(ipc___RecordBatchStreamWriter__Open( stream, schema))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type stream(stream_sexp); + Rcpp::traits::input_parameter&>::type schema(schema_sexp); + return Rcpp::wrap(ipc___RecordBatchStreamWriter__Open(stream, schema)); +END_RCPP } #else SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamWriter__Open(). "); } #endif +// table.cpp:27 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_dataframe(DataFrame tbl); SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type tbl(tbl_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_dataframe( tbl))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type tbl(tbl_sexp); + return Rcpp::wrap(Table__from_dataframe(tbl)); +END_RCPP } #else SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__from_dataframe(). "); } #endif +// table.cpp:36 #if defined(ARROW_R_WITH_ARROW) int Table__num_columns(const std::shared_ptr& x); SEXP _arrow_Table__num_columns(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__num_columns( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Table__num_columns(x)); +END_RCPP } #else SEXP _arrow_Table__num_columns(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__num_columns(). "); } #endif +// table.cpp:41 #if defined(ARROW_R_WITH_ARROW) int Table__num_rows(const std::shared_ptr& x); SEXP _arrow_Table__num_rows(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__num_rows( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Table__num_rows(x)); +END_RCPP } #else SEXP _arrow_Table__num_rows(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__num_rows(). "); } #endif +// table.cpp:44 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__schema(const std::shared_ptr& x); SEXP _arrow_Table__schema(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type x(x_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__schema( x))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type x(x_sexp); + return Rcpp::wrap(Table__schema(x)); +END_RCPP } #else SEXP _arrow_Table__schema(SEXP x_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__schema(). "); } #endif +// table.cpp:49 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__column(const std::shared_ptr& table, int i); SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type table(table_sexp); -Rcpp::traits::input_parameter::type i(i_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__column( table, i))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); + Rcpp::traits::input_parameter::type i(i_sexp); + return Rcpp::wrap(Table__column(table, i)); +END_RCPP } #else SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__column(). "); } #endif +// table.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::vector> Table__columns(const std::shared_ptr& table); SEXP _arrow_Table__columns(SEXP table_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter&>::type table(table_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__columns( table))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter&>::type table(table_sexp); + return Rcpp::wrap(Table__columns(table)); +END_RCPP } #else SEXP _arrow_Table__columns(SEXP table_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__columns(). "); } #endif +// table.cpp:74 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp); SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type lst(lst_sexp); -Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp);Rcpp::Shield rcpp_result_gen(Rcpp::wrap(Table__from_dots( lst, schema_sxp))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type lst(lst_sexp); + Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); + return Rcpp::wrap(Table__from_dots(lst, schema_sxp)); +END_RCPP } #else SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call Table__from_dots(). "); } #endif +// threadpool.cpp:42 #if defined(ARROW_R_WITH_ARROW) int GetCpuThreadPoolCapacity(); SEXP _arrow_GetCpuThreadPoolCapacity(){ - BEGIN_RCPP - Rcpp::Shield rcpp_result_gen(Rcpp::wrap(GetCpuThreadPoolCapacity( ))); -return rcpp_result_gen; - END_RCPP +BEGIN_RCPP + return Rcpp::wrap(GetCpuThreadPoolCapacity()); +END_RCPP } #else SEXP _arrow_GetCpuThreadPoolCapacity(){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call GetCpuThreadPoolCapacity(). "); } #endif +// threadpool.cpp:47 #if defined(ARROW_R_WITH_ARROW) void SetCpuThreadPoolCapacity(int threads); SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ - BEGIN_RCPP - Rcpp::traits::input_parameter::type threads(threads_sexp);SetCpuThreadPoolCapacity( threads); -return R_NilValue; - END_RCPP +BEGIN_RCPP + Rcpp::traits::input_parameter::type threads(threads_sexp); + SetCpuThreadPoolCapacity(threads); + return R_NilValue; +END_RCPP } #else SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ - BEGIN_RCPP - Rcpp::stop("arrow C++ library not available"); - END_RCPP + Rf_error("arrow C++ library not available. Cannot call SetCpuThreadPoolCapacity(). "); } #endif @@ -3421,214 +3210,214 @@ return Rf_ScalarLogical( static const R_CallMethodDef arrow_CallEntries[] = { { "_arrow_available", (DL_FUNC)& _arrow_available, 0 }, - { "_arrow_Array__Slice1", (DL_FUNC)& _arrow_Array__Slice1, 2 }, - { "_arrow_Array__Slice2", (DL_FUNC)& _arrow_Array__Slice2, 3 }, - { "_arrow_Array__IsNull", (DL_FUNC)& _arrow_Array__IsNull, 2 }, - { "_arrow_Array__IsValid", (DL_FUNC)& _arrow_Array__IsValid, 2 }, - { "_arrow_Array__length", (DL_FUNC)& _arrow_Array__length, 1 }, - { "_arrow_Array__offset", (DL_FUNC)& _arrow_Array__offset, 1 }, - { "_arrow_Array__null_count", (DL_FUNC)& _arrow_Array__null_count, 1 }, - { "_arrow_Array__type", (DL_FUNC)& _arrow_Array__type, 1 }, - { "_arrow_Array__ToString", (DL_FUNC)& _arrow_Array__ToString, 1 }, - { "_arrow_Array__type_id", (DL_FUNC)& _arrow_Array__type_id, 1 }, - { "_arrow_Array__Equals", (DL_FUNC)& _arrow_Array__Equals, 2 }, - { "_arrow_Array__ApproxEquals", (DL_FUNC)& _arrow_Array__ApproxEquals, 2 }, - { "_arrow_Array__data", (DL_FUNC)& _arrow_Array__data, 1 }, - { "_arrow_Array__RangeEquals", (DL_FUNC)& _arrow_Array__RangeEquals, 5 }, - { "_arrow_Array__Mask", (DL_FUNC)& _arrow_Array__Mask, 1 }, - { "_arrow_DictionaryArray__indices", (DL_FUNC)& _arrow_DictionaryArray__indices, 1 }, - { "_arrow_DictionaryArray__dictionary", (DL_FUNC)& _arrow_DictionaryArray__dictionary, 1 }, - { "_arrow_Array__as_vector", (DL_FUNC)& _arrow_Array__as_vector, 1 }, - { "_arrow_ChunkedArray__as_vector", (DL_FUNC)& _arrow_ChunkedArray__as_vector, 1 }, - { "_arrow_RecordBatch__to_dataframe", (DL_FUNC)& _arrow_RecordBatch__to_dataframe, 2 }, - { "_arrow_Table__to_dataframe", (DL_FUNC)& _arrow_Table__to_dataframe, 2 }, - { "_arrow_Array__infer_type", (DL_FUNC)& _arrow_Array__infer_type, 1 }, - { "_arrow_Array__from_vector", (DL_FUNC)& _arrow_Array__from_vector, 2 }, - { "_arrow_ChunkedArray__from_list", (DL_FUNC)& _arrow_ChunkedArray__from_list, 2 }, - { "_arrow_ArrayData__get_type", (DL_FUNC)& _arrow_ArrayData__get_type, 1 }, - { "_arrow_ArrayData__get_length", (DL_FUNC)& _arrow_ArrayData__get_length, 1 }, - { "_arrow_ArrayData__get_null_count", (DL_FUNC)& _arrow_ArrayData__get_null_count, 1 }, - { "_arrow_ArrayData__get_offset", (DL_FUNC)& _arrow_ArrayData__get_offset, 1 }, - { "_arrow_ArrayData__buffers", (DL_FUNC)& _arrow_ArrayData__buffers, 1 }, - { "_arrow_Buffer__is_mutable", (DL_FUNC)& _arrow_Buffer__is_mutable, 1 }, - { "_arrow_Buffer__ZeroPadding", (DL_FUNC)& _arrow_Buffer__ZeroPadding, 1 }, - { "_arrow_Buffer__capacity", (DL_FUNC)& _arrow_Buffer__capacity, 1 }, - { "_arrow_Buffer__size", (DL_FUNC)& _arrow_Buffer__size, 1 }, - { "_arrow_r___RBuffer__initialize", (DL_FUNC)& _arrow_r___RBuffer__initialize, 1 }, - { "_arrow_ChunkedArray__length", (DL_FUNC)& _arrow_ChunkedArray__length, 1 }, - { "_arrow_ChunkedArray__null_count", (DL_FUNC)& _arrow_ChunkedArray__null_count, 1 }, - { "_arrow_ChunkedArray__num_chunks", (DL_FUNC)& _arrow_ChunkedArray__num_chunks, 1 }, - { "_arrow_ChunkedArray__chunk", (DL_FUNC)& _arrow_ChunkedArray__chunk, 2 }, - { "_arrow_ChunkedArray__chunks", (DL_FUNC)& _arrow_ChunkedArray__chunks, 1 }, - { "_arrow_ChunkedArray__type", (DL_FUNC)& _arrow_ChunkedArray__type, 1 }, - { "_arrow_ChunkArray__Slice1", (DL_FUNC)& _arrow_ChunkArray__Slice1, 2 }, - { "_arrow_ChunkArray__Slice2", (DL_FUNC)& _arrow_ChunkArray__Slice2, 3 }, - { "_arrow_Column__length", (DL_FUNC)& _arrow_Column__length, 1 }, - { "_arrow_Column__null_count", (DL_FUNC)& _arrow_Column__null_count, 1 }, - { "_arrow_Column__type", (DL_FUNC)& _arrow_Column__type, 1 }, - { "_arrow_Column__data", (DL_FUNC)& _arrow_Column__data, 1 }, - { "_arrow_util___Codec__Create", (DL_FUNC)& _arrow_util___Codec__Create, 1 }, - { "_arrow_io___CompressedOutputStream__Make", (DL_FUNC)& _arrow_io___CompressedOutputStream__Make, 2 }, - { "_arrow_io___CompressedInputStream__Make", (DL_FUNC)& _arrow_io___CompressedInputStream__Make, 2 }, - { "_arrow_compute___CastOptions__initialize", (DL_FUNC)& _arrow_compute___CastOptions__initialize, 3 }, - { "_arrow_Array__cast", (DL_FUNC)& _arrow_Array__cast, 3 }, - { "_arrow_ChunkedArray__cast", (DL_FUNC)& _arrow_ChunkedArray__cast, 3 }, - { "_arrow_RecordBatch__cast", (DL_FUNC)& _arrow_RecordBatch__cast, 3 }, - { "_arrow_Table__cast", (DL_FUNC)& _arrow_Table__cast, 3 }, - { "_arrow_csv___ReadOptions__initialize", (DL_FUNC)& _arrow_csv___ReadOptions__initialize, 1 }, - { "_arrow_csv___ParseOptions__initialize", (DL_FUNC)& _arrow_csv___ParseOptions__initialize, 1 }, - { "_arrow_csv___ConvertOptions__initialize", (DL_FUNC)& _arrow_csv___ConvertOptions__initialize, 1 }, - { "_arrow_csv___TableReader__Make", (DL_FUNC)& _arrow_csv___TableReader__Make, 4 }, - { "_arrow_csv___TableReader__Read", (DL_FUNC)& _arrow_csv___TableReader__Read, 1 }, - { "_arrow_shared_ptr_is_null", (DL_FUNC)& _arrow_shared_ptr_is_null, 1 }, - { "_arrow_unique_ptr_is_null", (DL_FUNC)& _arrow_unique_ptr_is_null, 1 }, - { "_arrow_Int8__initialize", (DL_FUNC)& _arrow_Int8__initialize, 0 }, - { "_arrow_Int16__initialize", (DL_FUNC)& _arrow_Int16__initialize, 0 }, - { "_arrow_Int32__initialize", (DL_FUNC)& _arrow_Int32__initialize, 0 }, - { "_arrow_Int64__initialize", (DL_FUNC)& _arrow_Int64__initialize, 0 }, - { "_arrow_UInt8__initialize", (DL_FUNC)& _arrow_UInt8__initialize, 0 }, - { "_arrow_UInt16__initialize", (DL_FUNC)& _arrow_UInt16__initialize, 0 }, - { "_arrow_UInt32__initialize", (DL_FUNC)& _arrow_UInt32__initialize, 0 }, - { "_arrow_UInt64__initialize", (DL_FUNC)& _arrow_UInt64__initialize, 0 }, - { "_arrow_Float16__initialize", (DL_FUNC)& _arrow_Float16__initialize, 0 }, - { "_arrow_Float32__initialize", (DL_FUNC)& _arrow_Float32__initialize, 0 }, - { "_arrow_Float64__initialize", (DL_FUNC)& _arrow_Float64__initialize, 0 }, - { "_arrow_Boolean__initialize", (DL_FUNC)& _arrow_Boolean__initialize, 0 }, - { "_arrow_Utf8__initialize", (DL_FUNC)& _arrow_Utf8__initialize, 0 }, - { "_arrow_Date32__initialize", (DL_FUNC)& _arrow_Date32__initialize, 0 }, - { "_arrow_Date64__initialize", (DL_FUNC)& _arrow_Date64__initialize, 0 }, - { "_arrow_Null__initialize", (DL_FUNC)& _arrow_Null__initialize, 0 }, - { "_arrow_Decimal128Type__initialize", (DL_FUNC)& _arrow_Decimal128Type__initialize, 2 }, - { "_arrow_FixedSizeBinary__initialize", (DL_FUNC)& _arrow_FixedSizeBinary__initialize, 1 }, - { "_arrow_Timestamp__initialize1", (DL_FUNC)& _arrow_Timestamp__initialize1, 1 }, - { "_arrow_Timestamp__initialize2", (DL_FUNC)& _arrow_Timestamp__initialize2, 2 }, - { "_arrow_Time32__initialize", (DL_FUNC)& _arrow_Time32__initialize, 1 }, - { "_arrow_Time64__initialize", (DL_FUNC)& _arrow_Time64__initialize, 1 }, - { "_arrow_list__", (DL_FUNC)& _arrow_list__, 1 }, - { "_arrow_struct_", (DL_FUNC)& _arrow_struct_, 1 }, - { "_arrow_DataType__ToString", (DL_FUNC)& _arrow_DataType__ToString, 1 }, - { "_arrow_DataType__name", (DL_FUNC)& _arrow_DataType__name, 1 }, - { "_arrow_DataType__Equals", (DL_FUNC)& _arrow_DataType__Equals, 2 }, - { "_arrow_DataType__num_children", (DL_FUNC)& _arrow_DataType__num_children, 1 }, - { "_arrow_DataType__children_pointer", (DL_FUNC)& _arrow_DataType__children_pointer, 1 }, - { "_arrow_DataType__id", (DL_FUNC)& _arrow_DataType__id, 1 }, - { "_arrow_schema_", (DL_FUNC)& _arrow_schema_, 1 }, - { "_arrow_Schema__ToString", (DL_FUNC)& _arrow_Schema__ToString, 1 }, - { "_arrow_Schema__num_fields", (DL_FUNC)& _arrow_Schema__num_fields, 1 }, - { "_arrow_Schema__field", (DL_FUNC)& _arrow_Schema__field, 2 }, - { "_arrow_Schema__names", (DL_FUNC)& _arrow_Schema__names, 1 }, - { "_arrow_ListType__ToString", (DL_FUNC)& _arrow_ListType__ToString, 1 }, - { "_arrow_FixedWidthType__bit_width", (DL_FUNC)& _arrow_FixedWidthType__bit_width, 1 }, - { "_arrow_DateType__unit", (DL_FUNC)& _arrow_DateType__unit, 1 }, - { "_arrow_TimeType__unit", (DL_FUNC)& _arrow_TimeType__unit, 1 }, - { "_arrow_DecimalType__precision", (DL_FUNC)& _arrow_DecimalType__precision, 1 }, - { "_arrow_DecimalType__scale", (DL_FUNC)& _arrow_DecimalType__scale, 1 }, - { "_arrow_TimestampType__timezone", (DL_FUNC)& _arrow_TimestampType__timezone, 1 }, - { "_arrow_TimestampType__unit", (DL_FUNC)& _arrow_TimestampType__unit, 1 }, - { "_arrow_DictionaryType__initialize", (DL_FUNC)& _arrow_DictionaryType__initialize, 3 }, - { "_arrow_DictionaryType__index_type", (DL_FUNC)& _arrow_DictionaryType__index_type, 1 }, - { "_arrow_DictionaryType__value_type", (DL_FUNC)& _arrow_DictionaryType__value_type, 1 }, - { "_arrow_DictionaryType__name", (DL_FUNC)& _arrow_DictionaryType__name, 1 }, - { "_arrow_DictionaryType__ordered", (DL_FUNC)& _arrow_DictionaryType__ordered, 1 }, - { "_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetDescription, 2 }, - { "_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetNumRows, 2 }, - { "_arrow_ipc___feather___TableWriter__Append", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Append, 3 }, - { "_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Finalize, 1 }, - { "_arrow_ipc___feather___TableWriter__Open", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Open, 1 }, - { "_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC)& _arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2 }, - { "_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetDescription, 1 }, - { "_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__HasDescription, 1 }, - { "_arrow_ipc___feather___TableReader__version", (DL_FUNC)& _arrow_ipc___feather___TableReader__version, 1 }, - { "_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_rows, 1 }, - { "_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_columns, 1 }, - { "_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumnName, 2 }, - { "_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumn, 2 }, - { "_arrow_ipc___feather___TableReader__Read", (DL_FUNC)& _arrow_ipc___feather___TableReader__Read, 2 }, - { "_arrow_ipc___feather___TableReader__Open", (DL_FUNC)& _arrow_ipc___feather___TableReader__Open, 1 }, - { "_arrow_Field__initialize", (DL_FUNC)& _arrow_Field__initialize, 3 }, - { "_arrow_Field__ToString", (DL_FUNC)& _arrow_Field__ToString, 1 }, - { "_arrow_Field__name", (DL_FUNC)& _arrow_Field__name, 1 }, - { "_arrow_Field__Equals", (DL_FUNC)& _arrow_Field__Equals, 2 }, - { "_arrow_Field__nullable", (DL_FUNC)& _arrow_Field__nullable, 1 }, - { "_arrow_Field__type", (DL_FUNC)& _arrow_Field__type, 1 }, - { "_arrow_io___Readable__Read", (DL_FUNC)& _arrow_io___Readable__Read, 2 }, - { "_arrow_io___InputStream__Close", (DL_FUNC)& _arrow_io___InputStream__Close, 1 }, - { "_arrow_io___OutputStream__Close", (DL_FUNC)& _arrow_io___OutputStream__Close, 1 }, - { "_arrow_io___RandomAccessFile__GetSize", (DL_FUNC)& _arrow_io___RandomAccessFile__GetSize, 1 }, - { "_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC)& _arrow_io___RandomAccessFile__supports_zero_copy, 1 }, - { "_arrow_io___RandomAccessFile__Seek", (DL_FUNC)& _arrow_io___RandomAccessFile__Seek, 2 }, - { "_arrow_io___RandomAccessFile__Tell", (DL_FUNC)& _arrow_io___RandomAccessFile__Tell, 1 }, - { "_arrow_io___MemoryMappedFile__Create", (DL_FUNC)& _arrow_io___MemoryMappedFile__Create, 2 }, - { "_arrow_io___MemoryMappedFile__Open", (DL_FUNC)& _arrow_io___MemoryMappedFile__Open, 2 }, - { "_arrow_io___MemoryMappedFile__Resize", (DL_FUNC)& _arrow_io___MemoryMappedFile__Resize, 2 }, - { "_arrow_io___ReadableFile__Open", (DL_FUNC)& _arrow_io___ReadableFile__Open, 1 }, - { "_arrow_io___BufferReader__initialize", (DL_FUNC)& _arrow_io___BufferReader__initialize, 1 }, - { "_arrow_io___Writable__write", (DL_FUNC)& _arrow_io___Writable__write, 2 }, - { "_arrow_io___OutputStream__Tell", (DL_FUNC)& _arrow_io___OutputStream__Tell, 1 }, - { "_arrow_io___FileOutputStream__Open", (DL_FUNC)& _arrow_io___FileOutputStream__Open, 1 }, - { "_arrow_io___BufferOutputStream__Create", (DL_FUNC)& _arrow_io___BufferOutputStream__Create, 1 }, - { "_arrow_io___BufferOutputStream__capacity", (DL_FUNC)& _arrow_io___BufferOutputStream__capacity, 1 }, - { "_arrow_io___BufferOutputStream__Finish", (DL_FUNC)& _arrow_io___BufferOutputStream__Finish, 1 }, - { "_arrow_io___BufferOutputStream__Tell", (DL_FUNC)& _arrow_io___BufferOutputStream__Tell, 1 }, - { "_arrow_io___BufferOutputStream__Write", (DL_FUNC)& _arrow_io___BufferOutputStream__Write, 2 }, - { "_arrow_io___MockOutputStream__initialize", (DL_FUNC)& _arrow_io___MockOutputStream__initialize, 0 }, - { "_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC)& _arrow_io___MockOutputStream__GetExtentBytesWritten, 1 }, - { "_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC)& _arrow_io___FixedSizeBufferWriter__initialize, 1 }, - { "_arrow_MemoryPool__default", (DL_FUNC)& _arrow_MemoryPool__default, 0 }, - { "_arrow_MemoryPool__bytes_allocated", (DL_FUNC)& _arrow_MemoryPool__bytes_allocated, 1 }, - { "_arrow_MemoryPool__max_memory", (DL_FUNC)& _arrow_MemoryPool__max_memory, 1 }, - { "_arrow_ipc___Message__body_length", (DL_FUNC)& _arrow_ipc___Message__body_length, 1 }, - { "_arrow_ipc___Message__metadata", (DL_FUNC)& _arrow_ipc___Message__metadata, 1 }, - { "_arrow_ipc___Message__body", (DL_FUNC)& _arrow_ipc___Message__body, 1 }, - { "_arrow_ipc___Message__Verify", (DL_FUNC)& _arrow_ipc___Message__Verify, 1 }, - { "_arrow_ipc___Message__type", (DL_FUNC)& _arrow_ipc___Message__type, 1 }, - { "_arrow_ipc___Message__Equals", (DL_FUNC)& _arrow_ipc___Message__Equals, 2 }, - { "_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__Message__Schema, 2 }, - { "_arrow_ipc___ReadSchema_InputStream", (DL_FUNC)& _arrow_ipc___ReadSchema_InputStream, 1 }, - { "_arrow_ipc___MessageReader__Open", (DL_FUNC)& _arrow_ipc___MessageReader__Open, 1 }, - { "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC)& _arrow_ipc___MessageReader__ReadNextMessage, 1 }, - { "_arrow_ipc___ReadMessage", (DL_FUNC)& _arrow_ipc___ReadMessage, 1 }, - { "_arrow_read_parquet_file", (DL_FUNC)& _arrow_read_parquet_file, 1 }, - { "_arrow_RecordBatch__num_columns", (DL_FUNC)& _arrow_RecordBatch__num_columns, 1 }, - { "_arrow_RecordBatch__num_rows", (DL_FUNC)& _arrow_RecordBatch__num_rows, 1 }, - { "_arrow_RecordBatch__schema", (DL_FUNC)& _arrow_RecordBatch__schema, 1 }, - { "_arrow_RecordBatch__columns", (DL_FUNC)& _arrow_RecordBatch__columns, 1 }, - { "_arrow_RecordBatch__column", (DL_FUNC)& _arrow_RecordBatch__column, 2 }, - { "_arrow_RecordBatch__from_dataframe", (DL_FUNC)& _arrow_RecordBatch__from_dataframe, 1 }, - { "_arrow_RecordBatch__Equals", (DL_FUNC)& _arrow_RecordBatch__Equals, 2 }, - { "_arrow_RecordBatch__RemoveColumn", (DL_FUNC)& _arrow_RecordBatch__RemoveColumn, 2 }, - { "_arrow_RecordBatch__column_name", (DL_FUNC)& _arrow_RecordBatch__column_name, 2 }, - { "_arrow_RecordBatch__names", (DL_FUNC)& _arrow_RecordBatch__names, 1 }, - { "_arrow_RecordBatch__Slice1", (DL_FUNC)& _arrow_RecordBatch__Slice1, 2 }, - { "_arrow_RecordBatch__Slice2", (DL_FUNC)& _arrow_RecordBatch__Slice2, 3 }, - { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC)& _arrow_ipc___SerializeRecordBatch__Raw, 1 }, - { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__InputStream__Schema, 2 }, - { "_arrow_RecordBatch__from_arrays", (DL_FUNC)& _arrow_RecordBatch__from_arrays, 2 }, - { "_arrow_RecordBatchReader__schema", (DL_FUNC)& _arrow_RecordBatchReader__schema, 1 }, - { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC)& _arrow_RecordBatchReader__ReadNext, 1 }, - { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__Open, 1 }, - { "_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__batches, 1 }, - { "_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__schema, 1 }, - { "_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__num_record_batches, 1 }, - { "_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2 }, - { "_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__Open, 1 }, - { "_arrow_Table__from_RecordBatchFileReader", (DL_FUNC)& _arrow_Table__from_RecordBatchFileReader, 1 }, - { "_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC)& _arrow_Table__from_RecordBatchStreamReader, 1 }, - { "_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__batches, 1 }, - { "_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2 }, - { "_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteTable, 2 }, - { "_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__Close, 1 }, - { "_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileWriter__Open, 2 }, - { "_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamWriter__Open, 2 }, - { "_arrow_Table__from_dataframe", (DL_FUNC)& _arrow_Table__from_dataframe, 1 }, - { "_arrow_Table__num_columns", (DL_FUNC)& _arrow_Table__num_columns, 1 }, - { "_arrow_Table__num_rows", (DL_FUNC)& _arrow_Table__num_rows, 1 }, - { "_arrow_Table__schema", (DL_FUNC)& _arrow_Table__schema, 1 }, - { "_arrow_Table__column", (DL_FUNC)& _arrow_Table__column, 2 }, - { "_arrow_Table__columns", (DL_FUNC)& _arrow_Table__columns, 1 }, - { "_arrow_Table__from_dots", (DL_FUNC)& _arrow_Table__from_dots, 2 }, - { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_GetCpuThreadPoolCapacity, 0 }, - { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_SetCpuThreadPoolCapacity, 1 }, + { "_arrow_Array__Slice1", (DL_FUNC)& _arrow_Array__Slice1, 2}, + { "_arrow_Array__Slice2", (DL_FUNC)& _arrow_Array__Slice2, 3}, + { "_arrow_Array__IsNull", (DL_FUNC)& _arrow_Array__IsNull, 2}, + { "_arrow_Array__IsValid", (DL_FUNC)& _arrow_Array__IsValid, 2}, + { "_arrow_Array__length", (DL_FUNC)& _arrow_Array__length, 1}, + { "_arrow_Array__offset", (DL_FUNC)& _arrow_Array__offset, 1}, + { "_arrow_Array__null_count", (DL_FUNC)& _arrow_Array__null_count, 1}, + { "_arrow_Array__type", (DL_FUNC)& _arrow_Array__type, 1}, + { "_arrow_Array__ToString", (DL_FUNC)& _arrow_Array__ToString, 1}, + { "_arrow_Array__type_id", (DL_FUNC)& _arrow_Array__type_id, 1}, + { "_arrow_Array__Equals", (DL_FUNC)& _arrow_Array__Equals, 2}, + { "_arrow_Array__ApproxEquals", (DL_FUNC)& _arrow_Array__ApproxEquals, 2}, + { "_arrow_Array__data", (DL_FUNC)& _arrow_Array__data, 1}, + { "_arrow_Array__RangeEquals", (DL_FUNC)& _arrow_Array__RangeEquals, 5}, + { "_arrow_Array__Mask", (DL_FUNC)& _arrow_Array__Mask, 1}, + { "_arrow_DictionaryArray__indices", (DL_FUNC)& _arrow_DictionaryArray__indices, 1}, + { "_arrow_DictionaryArray__dictionary", (DL_FUNC)& _arrow_DictionaryArray__dictionary, 1}, + { "_arrow_Array__as_vector", (DL_FUNC)& _arrow_Array__as_vector, 1}, + { "_arrow_ChunkedArray__as_vector", (DL_FUNC)& _arrow_ChunkedArray__as_vector, 1}, + { "_arrow_RecordBatch__to_dataframe", (DL_FUNC)& _arrow_RecordBatch__to_dataframe, 2}, + { "_arrow_Table__to_dataframe", (DL_FUNC)& _arrow_Table__to_dataframe, 2}, + { "_arrow_Array__infer_type", (DL_FUNC)& _arrow_Array__infer_type, 1}, + { "_arrow_Array__from_vector", (DL_FUNC)& _arrow_Array__from_vector, 2}, + { "_arrow_ChunkedArray__from_list", (DL_FUNC)& _arrow_ChunkedArray__from_list, 2}, + { "_arrow_ArrayData__get_type", (DL_FUNC)& _arrow_ArrayData__get_type, 1}, + { "_arrow_ArrayData__get_length", (DL_FUNC)& _arrow_ArrayData__get_length, 1}, + { "_arrow_ArrayData__get_null_count", (DL_FUNC)& _arrow_ArrayData__get_null_count, 1}, + { "_arrow_ArrayData__get_offset", (DL_FUNC)& _arrow_ArrayData__get_offset, 1}, + { "_arrow_ArrayData__buffers", (DL_FUNC)& _arrow_ArrayData__buffers, 1}, + { "_arrow_Buffer__is_mutable", (DL_FUNC)& _arrow_Buffer__is_mutable, 1}, + { "_arrow_Buffer__ZeroPadding", (DL_FUNC)& _arrow_Buffer__ZeroPadding, 1}, + { "_arrow_Buffer__capacity", (DL_FUNC)& _arrow_Buffer__capacity, 1}, + { "_arrow_Buffer__size", (DL_FUNC)& _arrow_Buffer__size, 1}, + { "_arrow_r___RBuffer__initialize", (DL_FUNC)& _arrow_r___RBuffer__initialize, 1}, + { "_arrow_ChunkedArray__length", (DL_FUNC)& _arrow_ChunkedArray__length, 1}, + { "_arrow_ChunkedArray__null_count", (DL_FUNC)& _arrow_ChunkedArray__null_count, 1}, + { "_arrow_ChunkedArray__num_chunks", (DL_FUNC)& _arrow_ChunkedArray__num_chunks, 1}, + { "_arrow_ChunkedArray__chunk", (DL_FUNC)& _arrow_ChunkedArray__chunk, 2}, + { "_arrow_ChunkedArray__chunks", (DL_FUNC)& _arrow_ChunkedArray__chunks, 1}, + { "_arrow_ChunkedArray__type", (DL_FUNC)& _arrow_ChunkedArray__type, 1}, + { "_arrow_ChunkArray__Slice1", (DL_FUNC)& _arrow_ChunkArray__Slice1, 2}, + { "_arrow_ChunkArray__Slice2", (DL_FUNC)& _arrow_ChunkArray__Slice2, 3}, + { "_arrow_Column__length", (DL_FUNC)& _arrow_Column__length, 1}, + { "_arrow_Column__null_count", (DL_FUNC)& _arrow_Column__null_count, 1}, + { "_arrow_Column__type", (DL_FUNC)& _arrow_Column__type, 1}, + { "_arrow_Column__data", (DL_FUNC)& _arrow_Column__data, 1}, + { "_arrow_util___Codec__Create", (DL_FUNC)& _arrow_util___Codec__Create, 1}, + { "_arrow_io___CompressedOutputStream__Make", (DL_FUNC)& _arrow_io___CompressedOutputStream__Make, 2}, + { "_arrow_io___CompressedInputStream__Make", (DL_FUNC)& _arrow_io___CompressedInputStream__Make, 2}, + { "_arrow_compute___CastOptions__initialize", (DL_FUNC)& _arrow_compute___CastOptions__initialize, 3}, + { "_arrow_Array__cast", (DL_FUNC)& _arrow_Array__cast, 3}, + { "_arrow_ChunkedArray__cast", (DL_FUNC)& _arrow_ChunkedArray__cast, 3}, + { "_arrow_RecordBatch__cast", (DL_FUNC)& _arrow_RecordBatch__cast, 3}, + { "_arrow_Table__cast", (DL_FUNC)& _arrow_Table__cast, 3}, + { "_arrow_csv___ReadOptions__initialize", (DL_FUNC)& _arrow_csv___ReadOptions__initialize, 1}, + { "_arrow_csv___ParseOptions__initialize", (DL_FUNC)& _arrow_csv___ParseOptions__initialize, 1}, + { "_arrow_csv___ConvertOptions__initialize", (DL_FUNC)& _arrow_csv___ConvertOptions__initialize, 1}, + { "_arrow_csv___TableReader__Make", (DL_FUNC)& _arrow_csv___TableReader__Make, 4}, + { "_arrow_csv___TableReader__Read", (DL_FUNC)& _arrow_csv___TableReader__Read, 1}, + { "_arrow_shared_ptr_is_null", (DL_FUNC)& _arrow_shared_ptr_is_null, 1}, + { "_arrow_unique_ptr_is_null", (DL_FUNC)& _arrow_unique_ptr_is_null, 1}, + { "_arrow_Int8__initialize", (DL_FUNC)& _arrow_Int8__initialize, 0}, + { "_arrow_Int16__initialize", (DL_FUNC)& _arrow_Int16__initialize, 0}, + { "_arrow_Int32__initialize", (DL_FUNC)& _arrow_Int32__initialize, 0}, + { "_arrow_Int64__initialize", (DL_FUNC)& _arrow_Int64__initialize, 0}, + { "_arrow_UInt8__initialize", (DL_FUNC)& _arrow_UInt8__initialize, 0}, + { "_arrow_UInt16__initialize", (DL_FUNC)& _arrow_UInt16__initialize, 0}, + { "_arrow_UInt32__initialize", (DL_FUNC)& _arrow_UInt32__initialize, 0}, + { "_arrow_UInt64__initialize", (DL_FUNC)& _arrow_UInt64__initialize, 0}, + { "_arrow_Float16__initialize", (DL_FUNC)& _arrow_Float16__initialize, 0}, + { "_arrow_Float32__initialize", (DL_FUNC)& _arrow_Float32__initialize, 0}, + { "_arrow_Float64__initialize", (DL_FUNC)& _arrow_Float64__initialize, 0}, + { "_arrow_Boolean__initialize", (DL_FUNC)& _arrow_Boolean__initialize, 0}, + { "_arrow_Utf8__initialize", (DL_FUNC)& _arrow_Utf8__initialize, 0}, + { "_arrow_Date32__initialize", (DL_FUNC)& _arrow_Date32__initialize, 0}, + { "_arrow_Date64__initialize", (DL_FUNC)& _arrow_Date64__initialize, 0}, + { "_arrow_Null__initialize", (DL_FUNC)& _arrow_Null__initialize, 0}, + { "_arrow_Decimal128Type__initialize", (DL_FUNC)& _arrow_Decimal128Type__initialize, 2}, + { "_arrow_FixedSizeBinary__initialize", (DL_FUNC)& _arrow_FixedSizeBinary__initialize, 1}, + { "_arrow_Timestamp__initialize1", (DL_FUNC)& _arrow_Timestamp__initialize1, 1}, + { "_arrow_Timestamp__initialize2", (DL_FUNC)& _arrow_Timestamp__initialize2, 2}, + { "_arrow_Time32__initialize", (DL_FUNC)& _arrow_Time32__initialize, 1}, + { "_arrow_Time64__initialize", (DL_FUNC)& _arrow_Time64__initialize, 1}, + { "_arrow_list__", (DL_FUNC)& _arrow_list__, 1}, + { "_arrow_struct_", (DL_FUNC)& _arrow_struct_, 1}, + { "_arrow_DataType__ToString", (DL_FUNC)& _arrow_DataType__ToString, 1}, + { "_arrow_DataType__name", (DL_FUNC)& _arrow_DataType__name, 1}, + { "_arrow_DataType__Equals", (DL_FUNC)& _arrow_DataType__Equals, 2}, + { "_arrow_DataType__num_children", (DL_FUNC)& _arrow_DataType__num_children, 1}, + { "_arrow_DataType__children_pointer", (DL_FUNC)& _arrow_DataType__children_pointer, 1}, + { "_arrow_DataType__id", (DL_FUNC)& _arrow_DataType__id, 1}, + { "_arrow_schema_", (DL_FUNC)& _arrow_schema_, 1}, + { "_arrow_Schema__ToString", (DL_FUNC)& _arrow_Schema__ToString, 1}, + { "_arrow_Schema__num_fields", (DL_FUNC)& _arrow_Schema__num_fields, 1}, + { "_arrow_Schema__field", (DL_FUNC)& _arrow_Schema__field, 2}, + { "_arrow_Schema__names", (DL_FUNC)& _arrow_Schema__names, 1}, + { "_arrow_ListType__ToString", (DL_FUNC)& _arrow_ListType__ToString, 1}, + { "_arrow_FixedWidthType__bit_width", (DL_FUNC)& _arrow_FixedWidthType__bit_width, 1}, + { "_arrow_DateType__unit", (DL_FUNC)& _arrow_DateType__unit, 1}, + { "_arrow_TimeType__unit", (DL_FUNC)& _arrow_TimeType__unit, 1}, + { "_arrow_DecimalType__precision", (DL_FUNC)& _arrow_DecimalType__precision, 1}, + { "_arrow_DecimalType__scale", (DL_FUNC)& _arrow_DecimalType__scale, 1}, + { "_arrow_TimestampType__timezone", (DL_FUNC)& _arrow_TimestampType__timezone, 1}, + { "_arrow_TimestampType__unit", (DL_FUNC)& _arrow_TimestampType__unit, 1}, + { "_arrow_DictionaryType__initialize", (DL_FUNC)& _arrow_DictionaryType__initialize, 3}, + { "_arrow_DictionaryType__index_type", (DL_FUNC)& _arrow_DictionaryType__index_type, 1}, + { "_arrow_DictionaryType__value_type", (DL_FUNC)& _arrow_DictionaryType__value_type, 1}, + { "_arrow_DictionaryType__name", (DL_FUNC)& _arrow_DictionaryType__name, 1}, + { "_arrow_DictionaryType__ordered", (DL_FUNC)& _arrow_DictionaryType__ordered, 1}, + { "_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetDescription, 2}, + { "_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetNumRows, 2}, + { "_arrow_ipc___feather___TableWriter__Append", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Append, 3}, + { "_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Finalize, 1}, + { "_arrow_ipc___feather___TableWriter__Open", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Open, 1}, + { "_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC)& _arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2}, + { "_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetDescription, 1}, + { "_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__HasDescription, 1}, + { "_arrow_ipc___feather___TableReader__version", (DL_FUNC)& _arrow_ipc___feather___TableReader__version, 1}, + { "_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_rows, 1}, + { "_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_columns, 1}, + { "_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumnName, 2}, + { "_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumn, 2}, + { "_arrow_ipc___feather___TableReader__Read", (DL_FUNC)& _arrow_ipc___feather___TableReader__Read, 2}, + { "_arrow_ipc___feather___TableReader__Open", (DL_FUNC)& _arrow_ipc___feather___TableReader__Open, 1}, + { "_arrow_Field__initialize", (DL_FUNC)& _arrow_Field__initialize, 3}, + { "_arrow_Field__ToString", (DL_FUNC)& _arrow_Field__ToString, 1}, + { "_arrow_Field__name", (DL_FUNC)& _arrow_Field__name, 1}, + { "_arrow_Field__Equals", (DL_FUNC)& _arrow_Field__Equals, 2}, + { "_arrow_Field__nullable", (DL_FUNC)& _arrow_Field__nullable, 1}, + { "_arrow_Field__type", (DL_FUNC)& _arrow_Field__type, 1}, + { "_arrow_io___Readable__Read", (DL_FUNC)& _arrow_io___Readable__Read, 2}, + { "_arrow_io___InputStream__Close", (DL_FUNC)& _arrow_io___InputStream__Close, 1}, + { "_arrow_io___OutputStream__Close", (DL_FUNC)& _arrow_io___OutputStream__Close, 1}, + { "_arrow_io___RandomAccessFile__GetSize", (DL_FUNC)& _arrow_io___RandomAccessFile__GetSize, 1}, + { "_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC)& _arrow_io___RandomAccessFile__supports_zero_copy, 1}, + { "_arrow_io___RandomAccessFile__Seek", (DL_FUNC)& _arrow_io___RandomAccessFile__Seek, 2}, + { "_arrow_io___RandomAccessFile__Tell", (DL_FUNC)& _arrow_io___RandomAccessFile__Tell, 1}, + { "_arrow_io___MemoryMappedFile__Create", (DL_FUNC)& _arrow_io___MemoryMappedFile__Create, 2}, + { "_arrow_io___MemoryMappedFile__Open", (DL_FUNC)& _arrow_io___MemoryMappedFile__Open, 2}, + { "_arrow_io___MemoryMappedFile__Resize", (DL_FUNC)& _arrow_io___MemoryMappedFile__Resize, 2}, + { "_arrow_io___ReadableFile__Open", (DL_FUNC)& _arrow_io___ReadableFile__Open, 1}, + { "_arrow_io___BufferReader__initialize", (DL_FUNC)& _arrow_io___BufferReader__initialize, 1}, + { "_arrow_io___Writable__write", (DL_FUNC)& _arrow_io___Writable__write, 2}, + { "_arrow_io___OutputStream__Tell", (DL_FUNC)& _arrow_io___OutputStream__Tell, 1}, + { "_arrow_io___FileOutputStream__Open", (DL_FUNC)& _arrow_io___FileOutputStream__Open, 1}, + { "_arrow_io___BufferOutputStream__Create", (DL_FUNC)& _arrow_io___BufferOutputStream__Create, 1}, + { "_arrow_io___BufferOutputStream__capacity", (DL_FUNC)& _arrow_io___BufferOutputStream__capacity, 1}, + { "_arrow_io___BufferOutputStream__Finish", (DL_FUNC)& _arrow_io___BufferOutputStream__Finish, 1}, + { "_arrow_io___BufferOutputStream__Tell", (DL_FUNC)& _arrow_io___BufferOutputStream__Tell, 1}, + { "_arrow_io___BufferOutputStream__Write", (DL_FUNC)& _arrow_io___BufferOutputStream__Write, 2}, + { "_arrow_io___MockOutputStream__initialize", (DL_FUNC)& _arrow_io___MockOutputStream__initialize, 0}, + { "_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC)& _arrow_io___MockOutputStream__GetExtentBytesWritten, 1}, + { "_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC)& _arrow_io___FixedSizeBufferWriter__initialize, 1}, + { "_arrow_MemoryPool__default", (DL_FUNC)& _arrow_MemoryPool__default, 0}, + { "_arrow_MemoryPool__bytes_allocated", (DL_FUNC)& _arrow_MemoryPool__bytes_allocated, 1}, + { "_arrow_MemoryPool__max_memory", (DL_FUNC)& _arrow_MemoryPool__max_memory, 1}, + { "_arrow_ipc___Message__body_length", (DL_FUNC)& _arrow_ipc___Message__body_length, 1}, + { "_arrow_ipc___Message__metadata", (DL_FUNC)& _arrow_ipc___Message__metadata, 1}, + { "_arrow_ipc___Message__body", (DL_FUNC)& _arrow_ipc___Message__body, 1}, + { "_arrow_ipc___Message__Verify", (DL_FUNC)& _arrow_ipc___Message__Verify, 1}, + { "_arrow_ipc___Message__type", (DL_FUNC)& _arrow_ipc___Message__type, 1}, + { "_arrow_ipc___Message__Equals", (DL_FUNC)& _arrow_ipc___Message__Equals, 2}, + { "_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__Message__Schema, 2}, + { "_arrow_ipc___ReadSchema_InputStream", (DL_FUNC)& _arrow_ipc___ReadSchema_InputStream, 1}, + { "_arrow_ipc___MessageReader__Open", (DL_FUNC)& _arrow_ipc___MessageReader__Open, 1}, + { "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC)& _arrow_ipc___MessageReader__ReadNextMessage, 1}, + { "_arrow_ipc___ReadMessage", (DL_FUNC)& _arrow_ipc___ReadMessage, 1}, + { "_arrow_read_parquet_file", (DL_FUNC)& _arrow_read_parquet_file, 1}, + { "_arrow_RecordBatch__num_columns", (DL_FUNC)& _arrow_RecordBatch__num_columns, 1}, + { "_arrow_RecordBatch__num_rows", (DL_FUNC)& _arrow_RecordBatch__num_rows, 1}, + { "_arrow_RecordBatch__schema", (DL_FUNC)& _arrow_RecordBatch__schema, 1}, + { "_arrow_RecordBatch__columns", (DL_FUNC)& _arrow_RecordBatch__columns, 1}, + { "_arrow_RecordBatch__column", (DL_FUNC)& _arrow_RecordBatch__column, 2}, + { "_arrow_RecordBatch__from_dataframe", (DL_FUNC)& _arrow_RecordBatch__from_dataframe, 1}, + { "_arrow_RecordBatch__Equals", (DL_FUNC)& _arrow_RecordBatch__Equals, 2}, + { "_arrow_RecordBatch__RemoveColumn", (DL_FUNC)& _arrow_RecordBatch__RemoveColumn, 2}, + { "_arrow_RecordBatch__column_name", (DL_FUNC)& _arrow_RecordBatch__column_name, 2}, + { "_arrow_RecordBatch__names", (DL_FUNC)& _arrow_RecordBatch__names, 1}, + { "_arrow_RecordBatch__Slice1", (DL_FUNC)& _arrow_RecordBatch__Slice1, 2}, + { "_arrow_RecordBatch__Slice2", (DL_FUNC)& _arrow_RecordBatch__Slice2, 3}, + { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC)& _arrow_ipc___SerializeRecordBatch__Raw, 1}, + { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__InputStream__Schema, 2}, + { "_arrow_RecordBatch__from_arrays", (DL_FUNC)& _arrow_RecordBatch__from_arrays, 2}, + { "_arrow_RecordBatchReader__schema", (DL_FUNC)& _arrow_RecordBatchReader__schema, 1}, + { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC)& _arrow_RecordBatchReader__ReadNext, 1}, + { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__Open, 1}, + { "_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__batches, 1}, + { "_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__schema, 1}, + { "_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__num_record_batches, 1}, + { "_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2}, + { "_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__Open, 1}, + { "_arrow_Table__from_RecordBatchFileReader", (DL_FUNC)& _arrow_Table__from_RecordBatchFileReader, 1}, + { "_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC)& _arrow_Table__from_RecordBatchStreamReader, 1}, + { "_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__batches, 1}, + { "_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2}, + { "_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteTable, 2}, + { "_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__Close, 1}, + { "_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileWriter__Open, 2}, + { "_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamWriter__Open, 2}, + { "_arrow_Table__from_dataframe", (DL_FUNC)& _arrow_Table__from_dataframe, 1}, + { "_arrow_Table__num_columns", (DL_FUNC)& _arrow_Table__num_columns, 1}, + { "_arrow_Table__num_rows", (DL_FUNC)& _arrow_Table__num_rows, 1}, + { "_arrow_Table__schema", (DL_FUNC)& _arrow_Table__schema, 1}, + { "_arrow_Table__column", (DL_FUNC)& _arrow_Table__column, 2}, + { "_arrow_Table__columns", (DL_FUNC)& _arrow_Table__columns, 1}, + { "_arrow_Table__from_dots", (DL_FUNC)& _arrow_Table__from_dots, 2}, + { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_GetCpuThreadPoolCapacity, 0}, + { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_SetCpuThreadPoolCapacity, 1}, {NULL, NULL, 0} }; From d9e4f944cfe86d98ff3489dbad444b213cd67411 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 15:28:36 +0200 Subject: [PATCH 07/24] added a second R job to install and check the package on a system without libarrow --- .travis.yml | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index ab29ec8fdd5..8d6cbcdb1a9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -361,7 +361,22 @@ matrix: - pushd ${TRAVIS_BUILD_DIR}/r after_success: - Rscript ../ci/travis_upload_r_coverage.R - + - name: R_no_libarrow + language: r + cache: packages + latex: false + dist: xenial + before_install: + # Have to copy-paste this here because of how R's build steps work + - eval `python $TRAVIS_BUILD_DIR/ci/detect-changes.py` + - if [ $ARROW_CI_R_AFFECTED != "1" ]; then exit; fi + - | + if [ $TRAVIS_OS_NAME == "linux" ]; then + sudo bash -c "echo -e 'Acquire::Retries 10; Acquire::http::Timeout \"20\";' > /etc/apt/apt.conf.d/99-travis-retry" + sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + sudo apt-get update -qq + fi + - pushd ${TRAVIS_BUILD_DIR}/r after_failure: - | From 54ee38d414c0a47cace0ccb1bf22d2d9bac634e1 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Thu, 6 Jun 2019 15:37:56 +0200 Subject: [PATCH 08/24] :rat: --- r/data-raw/codegen.R | 17 +++++++++++++++++ r/tests/testthat/helper-arrow.R | 16 ++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index 69f583e3c21..ee578b6597c 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -1,3 +1,20 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + # pak::pkg_install("romainfrancois/decor") library(decor) diff --git a/r/tests/testthat/helper-arrow.R b/r/tests/testthat/helper-arrow.R index 875fbab2b66..88e1e76325b 100644 --- a/r/tests/testthat/helper-arrow.R +++ b/r/tests/testthat/helper-arrow.R @@ -1,3 +1,19 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. test_that <- function(what, code) { testthat::test_that(what, { From 84fa149f276a0ec38f55a18c9a7acab75778e831 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Fri, 7 Jun 2019 07:40:49 +0200 Subject: [PATCH 09/24] lint --- r/src/arrow_types.h | 35 ++++++++++++++++------------------- r/src/parquet.cpp | 1 - r/src/threadpool.cpp | 1 - 3 files changed, 16 insertions(+), 21 deletions(-) diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h index 93dae81961a..a1ac73011a1 100644 --- a/r/src/arrow_types.h +++ b/r/src/arrow_types.h @@ -27,9 +27,9 @@ #include "./symbols.h" #define STOP_IF_NOT(TEST, MSG) \ -do { \ - if (!(TEST)) Rcpp::stop(MSG); \ -} while (0) + do { \ + if (!(TEST)) Rcpp::stop(MSG); \ + } while (0) #define STOP_IF_NOT_OK(s) STOP_IF_NOT(s.ok(), s.ToString()) @@ -49,22 +49,22 @@ namespace internal { template Pointer r6_to_smart_pointer(SEXP self) { return reinterpret_cast( - EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); + EXTPTR_PTR(Rf_findVarInFrame(self, arrow::r::symbols::xp))); } } // namespace internal template class ConstReferenceSmartPtrInputParameter { -public: + public: using const_reference = const T&; explicit ConstReferenceSmartPtrInputParameter(SEXP self) - : ptr(internal::r6_to_smart_pointer(self)) {} + : ptr(internal::r6_to_smart_pointer(self)) {} inline operator const_reference() { return *ptr; } -private: + private: const T* ptr; }; @@ -158,8 +158,6 @@ inline std::shared_ptr extract(SEXP x) { } // namespace r } // namespace arrow - - #if defined(ARROW_R_WITH_ARROW) #include #include @@ -191,14 +189,13 @@ namespace arrow { namespace r { std::shared_ptr Array__from_vector( - SEXP x, const std::shared_ptr& type, bool type_infered -); + SEXP x, const std::shared_ptr& type, bool type_infered); template std::vector> List_to_shared_ptr_vector(SEXP x) { std::vector> vec; R_xlen_t n = Rf_xlength(x); - for (R_xlen_t i=0; i < n; i++) { + for (R_xlen_t i = 0; i < n; i++) { Rcpp::ConstReferenceSmartPtrInputParameter> ptr(VECTOR_ELT(x, i)); vec.push_back(ptr); } @@ -212,18 +209,18 @@ constexpr int64_t NA_INT64 = std::numeric_limits::min(); template > class RBuffer : public MutableBuffer { -public: + public: explicit RBuffer(Vec vec) - : MutableBuffer(reinterpret_cast(vec.begin()), - vec.size() * sizeof(typename Vec::stored_type)), - vec_(vec) {} + : MutableBuffer(reinterpret_cast(vec.begin()), + vec.size() * sizeof(typename Vec::stored_type)), + vec_(vec) {} -private: + private: // vec_ holds the memory Vec vec_; }; -} -} +} // namespace r +} // namespace arrow #endif diff --git a/r/src/parquet.cpp b/r/src/parquet.cpp index 07d3d1d2beb..f4f5fab947f 100644 --- a/r/src/parquet.cpp +++ b/r/src/parquet.cpp @@ -25,7 +25,6 @@ #include #endif - // [[arrow::export]] std::shared_ptr read_parquet_file(std::string filename) { #ifdef ARROW_R_WITH_PARQUET diff --git a/r/src/threadpool.cpp b/r/src/threadpool.cpp index 64f1246a873..b7a8c825045 100644 --- a/r/src/threadpool.cpp +++ b/r/src/threadpool.cpp @@ -21,7 +21,6 @@ #include - //' View and manage the capacity of the global thread pool //' //' Get the capacity of the global thread pool From e8ac3ea92c4889afffcc8b1220be8ff4e63edaf3 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Fri, 7 Jun 2019 08:56:12 +0200 Subject: [PATCH 10/24] using arrowExports.(R,cpp). update configure script --- cpp/build-support/lint_exclusions.txt | 1 + r/DESCRIPTION | 2 +- r/R/{generated.R => arrowExports.R} | 0 r/configure | 82 +++++++++++++++-------- r/data-raw/codegen.R | 39 +++++------ r/src/{generated.cpp => arrowExports.cpp} | 10 +-- 6 files changed, 77 insertions(+), 57 deletions(-) rename r/R/{generated.R => arrowExports.R} (100%) rename r/src/{generated.cpp => arrowExports.cpp} (99%) diff --git a/cpp/build-support/lint_exclusions.txt b/cpp/build-support/lint_exclusions.txt index 1187beb162d..448c1b1b4ae 100644 --- a/cpp/build-support/lint_exclusions.txt +++ b/cpp/build-support/lint_exclusions.txt @@ -8,3 +8,4 @@ *thirdparty/ae/* *vendored/* *RcppExports.cpp* +*arrowExports.cpp* diff --git a/r/DESCRIPTION b/r/DESCRIPTION index 6c25adfa382..d566f74856b 100644 --- a/r/DESCRIPTION +++ b/r/DESCRIPTION @@ -59,6 +59,7 @@ Collate: 'Struct.R' 'Table.R' 'array.R' + 'arrowExports.R' 'buffer.R' 'io.R' 'compression.R' @@ -66,7 +67,6 @@ Collate: 'csv.R' 'dictionary.R' 'feather.R' - 'generated.R' 'memory_pool.R' 'message.R' 'parquet.R' diff --git a/r/R/generated.R b/r/R/arrowExports.R similarity index 100% rename from r/R/generated.R rename to r/R/arrowExports.R diff --git a/r/configure b/r/configure index b548725f73a..3bb74e38c9c 100755 --- a/r/configure +++ b/r/configure @@ -33,11 +33,12 @@ PKG_BREW_NAME="apache-arrow" PKG_TEST_HEADER="" PKG_LIBS="-larrow -lparquet" -# Use pkg-config if available -pkg-config --version >/dev/null 2>&1 -if [ $? -eq 0 ]; then - PKGCONFIG_CFLAGS=`pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}` - PKGCONFIG_LIBS=`pkg-config --libs ${PKG_CONFIG_NAME}` +# generate code +if [ "$ARROW_R_DEV" == "TRUE" ]; then + echo "*** Generating code with data-raw/codegen.R" + ${R_HOME}/bin/Rscript data-raw/codegen.R +else + echo "Environment variable $$ARROW_R_DEV not set to TRUE, skip code generation" fi # Note that cflags may be empty in case of success @@ -45,19 +46,49 @@ if [ "$INCLUDE_DIR" ] || [ "$LIB_DIR" ]; then echo "Found INCLUDE_DIR and/or LIB_DIR!" PKG_CFLAGS="-I$INCLUDE_DIR $PKG_CFLAGS" PKG_LIBS="-L$LIB_DIR $PKG_LIBS" -elif [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then - echo "Found pkg-config cflags and libs!" - PKG_CFLAGS="$PKGCONFIG_CFLAGS" - PKG_LIBS=${PKGCONFIG_LIBS} -elif [[ "$OSTYPE" == "darwin"* ]]; then - if [ "$(command -v brew)" ]; then - BREWDIR=$(brew --prefix) +else + # Use pkg-config if available + pkg-config --version >/dev/null 2>&1 + if [ $? -eq 0 ]; then + echo "$ pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}" + PKGCONFIG_CFLAGS=`pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}` + echo "PKGCONFIG_CFLAGS = \"${PKGCONFIG_CFLAGS}\"" + + echo "$ pkg-config --libs ${PKG_CONFIG_NAME}" + PKGCONFIG_LIBS=`pkg-config --libs --silence-errors ${PKG_CONFIG_NAME}` + echo "PKGCONFIG_LIBS = \"${PKGCONFIG_LIBS}\"" + echo "" + fi + + if [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then + echo "Found pkg-config cflags and libs!" + PKG_CFLAGS="$PKGCONFIG_CFLAGS" + PKG_LIBS=${PKGCONFIG_LIBS} else - curl -sfL "https://jeroen.github.io/autobrew/$PKG_BREW_NAME" > autobrew - source autobrew + if [[ "$OSTYPE" == "darwin"* ]]; then + if [ "$(command -v brew)" ]; then + echo "brew is available" + BREWDIR=$(brew --prefix) + + if brew ls --versions apache-arrow > /dev/null; then + echo "Found brew install of apache-arrow formula" + PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include" + PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" + else + echo "apache-arrow brew formula not installed :/" + PKG_CFLAGS="" + PKG_LIBS="" + fi + else + echo "brew is not available, trying autobrew" + curl -sfL "https://jeroen.github.io/autobrew/$PKG_BREW_NAME" > autobrew + source autobrew + PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include" + PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" + fi + + fi fi - PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include" - PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" fi # Find compiler @@ -76,25 +107,18 @@ echo "#include $PKG_TEST_HEADER" | ${CXXCPP} ${CPPFLAGS} ${PKG_CFLAGS} ${CXX11FL # Customize the error if [ $? -ne 0 ]; then - echo "------------------------- ANTICONF ERROR ---------------------------" - echo "Configuration failed because $PKG_CONFIG_NAME was not found. Try installing:" - echo " * brew: $PKG_BREW_NAME (Mac OSX)" - echo "If $PKG_CONFIG_NAME is already installed, check that 'pkg-config' is in your" - echo "PATH and PKG_CONFIG_PATH contains a $PKG_CONFIG_NAME.pc file. If pkg-config" - echo "is unavailable you can set INCLUDE_DIR and LIB_DIR manually via:" - echo "R CMD INSTALL --configure-vars='INCLUDE_DIR=... LIB_DIR=...'" - echo "--------------------------------------------------------------------" - + echo "------------------------- NOTE ---------------------------" + echo "only installing shim version of the package" + echo "after installation, please run arrow::install_arrow()" + echo "---------------------------------------------------------" PKG_LIBS="" PKG_CFLAGS="" else PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_ARROW -DARROW_R_WITH_PARQUET" + echo "PKG_CFLAGS=$PKG_CFLAGS" + echo "PKG_LIBS=$PKG_LIBS" fi -# For debugging -echo "PKG_CFLAGS=$PKG_CFLAGS" -echo "PKG_LIBS=$PKG_LIBS" - # Write to Makevars sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index ee578b6597c..0d2ae680343 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -15,13 +15,15 @@ # specific language governing permissions and limitations # under the License. -# pak::pkg_install("romainfrancois/decor") -library(decor) +suppressPackageStartupMessages({ + # pak::pkg_install("romainfrancois/decor") + library(decor) -library(dplyr) -library(stringr) -library(purrr) -library(glue) + library(dplyr) + library(stringr) + library(purrr) + library(glue) +}) decorations <- cpp_decorations() %>% filter(decoration == "arrow::export") %>% @@ -32,24 +34,14 @@ decorations <- cpp_decorations() %>% { bind_cols(., bind_rows(pull(., functions))) } %>% select(-functions) +message(glue("*** > {n} functions decorated with [[arrow::export]]", n = nrow(decorations))) + glue_collapse_data <- function(data, ..., sep = ", ", last = "") { res <- glue_collapse(glue_data(data, ...), sep = sep, last = last) if(length(res) == 0) res <- "" res } -# sexp_params <- function(args){ -# glue_collapse_data(args, "SEXP {name}_sexp") -# } -# -# real_params <- function(args){ -# glue_collapse_data(args, "{type} {name}") -# } -# -# input_params <- function(args) { -# glue_collapse_data(args, "Rcpp::traits::input_parameter<{type}>::type {name}({name}_sexp);", sep = "\n", last = "\n") -# } - wrap_call <- function(name, return_type, args) { call <- glue::glue('{name}({list_params})', list_params = glue_collapse_data(args, "{name}")) if(return_type == "void") { @@ -93,7 +85,7 @@ cpp_functions_registration <- decorations %>% }) %>% glue_collapse(sep = "\n") -writeLines(con = "src/generated.cpp", glue::glue(' +writeLines(con = "src/arrowExports.cpp", glue::glue(' // Generated by using data-raw/codegen.R -> do not edit by hand #include "./arrow_types.h" #include @@ -112,19 +104,21 @@ return Rf_ScalarLogical( ); }} -static const R_CallMethodDef arrow_CallEntries[] = {{ +static const R_CallMethodDef CallEntries[] = {{ \t\t{{ "_arrow_available", (DL_FUNC)& _arrow_available, 0 }}, {cpp_functions_registration} \t\t{{NULL, NULL, 0}} }}; extern "C" void R_init_arrow(DllInfo* dll){{ - R_registerRoutines(dll, NULL, arrow_CallEntries, NULL, NULL); + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); }} ') ) +message(glue("*** > generated file `src/arrowExports.cpp`")) + r_functions <- decorations %>% select(name, return_type, args) %>% pmap_chr(function(name, return_type, args) { @@ -151,9 +145,10 @@ r_functions <- decorations %>% }) %>% glue_collapse(sep = "\n") -writeLines(con = "R/generated.R", glue::glue(' +writeLines(con = "R/arrowExports.R", glue::glue(' # Generated by using data-raw/codegen.R -> do not edit by hand {r_functions} ')) +message(glue("*** > generated file `R/arrowExports.R`")) diff --git a/r/src/generated.cpp b/r/src/arrowExports.cpp similarity index 99% rename from r/src/generated.cpp rename to r/src/arrowExports.cpp index 1ccd55426c7..b2bdf27bddc 100644 --- a/r/src/generated.cpp +++ b/r/src/arrowExports.cpp @@ -2563,7 +2563,7 @@ SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ } #endif -// parquet.cpp:29 +// parquet.cpp:28 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr read_parquet_file(std::string filename); SEXP _arrow_read_parquet_file(SEXP filename_sexp){ @@ -3167,7 +3167,7 @@ SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ } #endif -// threadpool.cpp:42 +// threadpool.cpp:41 #if defined(ARROW_R_WITH_ARROW) int GetCpuThreadPoolCapacity(); SEXP _arrow_GetCpuThreadPoolCapacity(){ @@ -3181,7 +3181,7 @@ SEXP _arrow_GetCpuThreadPoolCapacity(){ } #endif -// threadpool.cpp:47 +// threadpool.cpp:46 #if defined(ARROW_R_WITH_ARROW) void SetCpuThreadPoolCapacity(int threads); SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ @@ -3208,7 +3208,7 @@ return Rf_ScalarLogical( ); } -static const R_CallMethodDef arrow_CallEntries[] = { +static const R_CallMethodDef CallEntries[] = { { "_arrow_available", (DL_FUNC)& _arrow_available, 0 }, { "_arrow_Array__Slice1", (DL_FUNC)& _arrow_Array__Slice1, 2}, { "_arrow_Array__Slice2", (DL_FUNC)& _arrow_Array__Slice2, 3}, @@ -3422,7 +3422,7 @@ static const R_CallMethodDef arrow_CallEntries[] = { }; extern "C" void R_init_arrow(DllInfo* dll){ - R_registerRoutines(dll, NULL, arrow_CallEntries, NULL, NULL); + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } From bd7f30d73aa63efddde6c43698fbce8e3f584706 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Fri, 7 Jun 2019 09:12:18 +0200 Subject: [PATCH 11/24] :rat: --- dev/release/rat_exclude_files.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt index 06a6feb8b8f..c7747be7e48 100644 --- a/dev/release/rat_exclude_files.txt +++ b/dev/release/rat_exclude_files.txt @@ -192,8 +192,8 @@ csharp/test/Directory.Build.props *.svg *.devhelp2 *.scss -r/R/generated.R -r/src/generated.* +r/R/arrowExports.R +r/src/arrowExports.cpp r/DESCRIPTION r/LICENSE.md r/NAMESPACE From 75b0751a86e92ab1faf40c7fd1251bc69d083d4d Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Fri, 7 Jun 2019 10:55:19 +0200 Subject: [PATCH 12/24] Move symbols.h back into arrow_types.h --- r/src/arrow_types.h | 11 ++++++++++- r/src/symbols.h | 29 ----------------------------- 2 files changed, 10 insertions(+), 30 deletions(-) delete mode 100644 r/src/symbols.h diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h index a1ac73011a1..f2ea6dd1b04 100644 --- a/r/src/arrow_types.h +++ b/r/src/arrow_types.h @@ -24,7 +24,16 @@ #include #undef Free -#include "./symbols.h" +namespace arrow { +namespace r { +struct symbols { + static SEXP units; + static SEXP xp; + static SEXP dot_Internal; + static SEXP inspect; +}; +} // namespace r +} // namespace arrow #define STOP_IF_NOT(TEST, MSG) \ do { \ diff --git a/r/src/symbols.h b/r/src/symbols.h deleted file mode 100644 index 00dc997562a..00000000000 --- a/r/src/symbols.h +++ /dev/null @@ -1,29 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#pragma once - -namespace arrow { -namespace r { -struct symbols { - static SEXP units; - static SEXP xp; - static SEXP dot_Internal; - static SEXP inspect; -}; -} // namespace r -} // namespace arrow From 6c06581e7233c2b801dfd15771d84f19af5ab38a Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Fri, 7 Jun 2019 11:22:04 +0200 Subject: [PATCH 13/24] Using arrow:::arrow_available() --- r/tests/testthat/helper-arrow.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/r/tests/testthat/helper-arrow.R b/r/tests/testthat/helper-arrow.R index 88e1e76325b..5dd63e8520e 100644 --- a/r/tests/testthat/helper-arrow.R +++ b/r/tests/testthat/helper-arrow.R @@ -17,7 +17,7 @@ test_that <- function(what, code) { testthat::test_that(what, { - skip_if(!arrow_available(), "arrow C++ library not available") + skip_if(!arrow:::arrow_available(), "arrow C++ library not available") code }) } From 562670df3fa75b4ddb9efa7f41680d3e38534371 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Sat, 8 Jun 2019 12:38:38 +0200 Subject: [PATCH 14/24] RcppExport all the things --- r/data-raw/codegen.R | 8 +- r/src/arrowExports.cpp | 1250 ++++++++++++++++++++-------------------- 2 files changed, 629 insertions(+), 629 deletions(-) diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index 0d2ae680343..7dd77159412 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -57,13 +57,13 @@ cpp_functions_definitions <- decorations %>% // {basename(file)}:{line} #if defined(ARROW_R_WITH_ARROW) {return_type} {name}({real_params}); - SEXP _arrow_{name}({sexp_params}){{ + RcppExport SEXP _arrow_{name}({sexp_params}){{ BEGIN_RCPP {input_params}{return_line}{wrap_call(name, return_type, args)} END_RCPP }} #else - SEXP _arrow_{name}({sexp_params}){{ + RcppExport SEXP _arrow_{name}({sexp_params}){{ \tRf_error("arrow C++ library not available. Cannot call {name}(). "); }} #endif @@ -81,7 +81,7 @@ cpp_functions_definitions <- decorations %>% cpp_functions_registration <- decorations %>% select(name, return_type, args) %>% pmap_chr(function(name, return_type, args){ - glue('\t\t{{ "_arrow_{name}", (DL_FUNC)& _arrow_{name}, {nrow(args)}}}, ') + glue('\t\t{{ "_arrow_{name}", (DL_FUNC) &_arrow_{name}, {nrow(args)}}}, ') }) %>% glue_collapse(sep = "\n") @@ -110,7 +110,7 @@ static const R_CallMethodDef CallEntries[] = {{ \t\t{{NULL, NULL, 0}} }}; -extern "C" void R_init_arrow(DllInfo* dll){{ +RcppExport void R_init_arrow(DllInfo* dll){{ R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); }} diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp index b2bdf27bddc..a1aef203aa3 100644 --- a/r/src/arrowExports.cpp +++ b/r/src/arrowExports.cpp @@ -7,7 +7,7 @@ using namespace Rcpp; // array.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__Slice1(const std::shared_ptr& array, int offset); -SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -15,7 +15,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__Slice1(). "); } #endif @@ -23,7 +23,7 @@ SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ // array.cpp:31 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__Slice2(const std::shared_ptr& array, int offset, int length); -SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -32,7 +32,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__Slice2(). "); } #endif @@ -40,7 +40,7 @@ SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ // array.cpp:37 #if defined(ARROW_R_WITH_ARROW) bool Array__IsNull(const std::shared_ptr& x, int i); -SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -48,7 +48,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__IsNull(). "); } #endif @@ -56,7 +56,7 @@ SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ // array.cpp:40 #if defined(ARROW_R_WITH_ARROW) bool Array__IsValid(const std::shared_ptr& x, int i); -SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -64,7 +64,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__IsValid(). "); } #endif @@ -72,14 +72,14 @@ SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ // array.cpp:45 #if defined(ARROW_R_WITH_ARROW) int Array__length(const std::shared_ptr& x); -SEXP _arrow_Array__length(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__length(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__length(x)); END_RCPP } #else -SEXP _arrow_Array__length(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__length(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__length(). "); } #endif @@ -87,14 +87,14 @@ SEXP _arrow_Array__length(SEXP x_sexp){ // array.cpp:48 #if defined(ARROW_R_WITH_ARROW) int Array__offset(const std::shared_ptr& x); -SEXP _arrow_Array__offset(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__offset(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__offset(x)); END_RCPP } #else -SEXP _arrow_Array__offset(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__offset(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__offset(). "); } #endif @@ -102,14 +102,14 @@ SEXP _arrow_Array__offset(SEXP x_sexp){ // array.cpp:51 #if defined(ARROW_R_WITH_ARROW) int Array__null_count(const std::shared_ptr& x); -SEXP _arrow_Array__null_count(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__null_count(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__null_count(x)); END_RCPP } #else -SEXP _arrow_Array__null_count(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__null_count(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__null_count(). "); } #endif @@ -117,14 +117,14 @@ SEXP _arrow_Array__null_count(SEXP x_sexp){ // array.cpp:54 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__type(const std::shared_ptr& x); -SEXP _arrow_Array__type(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__type(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__type(x)); END_RCPP } #else -SEXP _arrow_Array__type(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__type(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__type(). "); } #endif @@ -132,14 +132,14 @@ SEXP _arrow_Array__type(SEXP x_sexp){ // array.cpp:59 #if defined(ARROW_R_WITH_ARROW) std::string Array__ToString(const std::shared_ptr& x); -SEXP _arrow_Array__ToString(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__ToString(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__ToString(x)); END_RCPP } #else -SEXP _arrow_Array__ToString(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__ToString(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__ToString(). "); } #endif @@ -147,14 +147,14 @@ SEXP _arrow_Array__ToString(SEXP x_sexp){ // array.cpp:64 #if defined(ARROW_R_WITH_ARROW) arrow::Type::type Array__type_id(const std::shared_ptr& x); -SEXP _arrow_Array__type_id(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__type_id(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Array__type_id(x)); END_RCPP } #else -SEXP _arrow_Array__type_id(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__type_id(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__type_id(). "); } #endif @@ -162,7 +162,7 @@ SEXP _arrow_Array__type_id(SEXP x_sexp){ // array.cpp:69 #if defined(ARROW_R_WITH_ARROW) bool Array__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); @@ -170,7 +170,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__Equals(). "); } #endif @@ -178,7 +178,7 @@ SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ // array.cpp:75 #if defined(ARROW_R_WITH_ARROW) bool Array__ApproxEquals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); @@ -186,7 +186,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__ApproxEquals(). "); } #endif @@ -194,14 +194,14 @@ SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ // array.cpp:81 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__data(const std::shared_ptr& array); -SEXP _arrow_Array__data(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__data(SEXP array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); return Rcpp::wrap(Array__data(array)); END_RCPP } #else -SEXP _arrow_Array__data(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__data(SEXP array_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__data(). "); } #endif @@ -209,7 +209,7 @@ SEXP _arrow_Array__data(SEXP array_sexp){ // array.cpp:87 #if defined(ARROW_R_WITH_ARROW) bool Array__RangeEquals(const std::shared_ptr& self, const std::shared_ptr& other, int start_idx, int end_idx, int other_start_idx); -SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ +RcppExport SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type self(self_sexp); Rcpp::traits::input_parameter&>::type other(other_sexp); @@ -220,7 +220,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ +RcppExport SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__RangeEquals(). "); } #endif @@ -228,14 +228,14 @@ SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_s // array.cpp:94 #if defined(ARROW_R_WITH_ARROW) LogicalVector Array__Mask(const std::shared_ptr& array); -SEXP _arrow_Array__Mask(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__Mask(SEXP array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); return Rcpp::wrap(Array__Mask(array)); END_RCPP } #else -SEXP _arrow_Array__Mask(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__Mask(SEXP array_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__Mask(). "); } #endif @@ -243,14 +243,14 @@ SEXP _arrow_Array__Mask(SEXP array_sexp){ // array.cpp:110 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryArray__indices(const std::shared_ptr& array); -SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ +RcppExport SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); return Rcpp::wrap(DictionaryArray__indices(array)); END_RCPP } #else -SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ +RcppExport SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryArray__indices(). "); } #endif @@ -258,14 +258,14 @@ SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ // array.cpp:116 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryArray__dictionary(const std::shared_ptr& array); -SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ +RcppExport SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); return Rcpp::wrap(DictionaryArray__dictionary(array)); END_RCPP } #else -SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ +RcppExport SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryArray__dictionary(). "); } #endif @@ -273,14 +273,14 @@ SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ // array__to_vector.cpp:669 #if defined(ARROW_R_WITH_ARROW) SEXP Array__as_vector(const std::shared_ptr& array); -SEXP _arrow_Array__as_vector(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__as_vector(SEXP array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); return Rcpp::wrap(Array__as_vector(array)); END_RCPP } #else -SEXP _arrow_Array__as_vector(SEXP array_sexp){ +RcppExport SEXP _arrow_Array__as_vector(SEXP array_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__as_vector(). "); } #endif @@ -288,14 +288,14 @@ SEXP _arrow_Array__as_vector(SEXP array_sexp){ // array__to_vector.cpp:674 #if defined(ARROW_R_WITH_ARROW) SEXP ChunkedArray__as_vector(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__as_vector(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__as_vector(). "); } #endif @@ -303,7 +303,7 @@ SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ // array__to_vector.cpp:680 #if defined(ARROW_R_WITH_ARROW) Rcpp::List RecordBatch__to_dataframe(const std::shared_ptr& batch, bool use_threads); -SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ +RcppExport SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); Rcpp::traits::input_parameter::type use_threads(use_threads_sexp); @@ -311,7 +311,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ +RcppExport SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__to_dataframe(). "); } #endif @@ -319,7 +319,7 @@ SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ // array__to_vector.cpp:702 #if defined(ARROW_R_WITH_ARROW) Rcpp::List Table__to_dataframe(const std::shared_ptr& table, bool use_threads); -SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ +RcppExport SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type table(table_sexp); Rcpp::traits::input_parameter::type use_threads(use_threads_sexp); @@ -327,7 +327,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ +RcppExport SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__to_dataframe(). "); } #endif @@ -335,14 +335,14 @@ SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ // array_from_vector.cpp:959 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__infer_type(SEXP x); -SEXP _arrow_Array__infer_type(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__infer_type(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type x(x_sexp); return Rcpp::wrap(Array__infer_type(x)); END_RCPP } #else -SEXP _arrow_Array__infer_type(SEXP x_sexp){ +RcppExport SEXP _arrow_Array__infer_type(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__infer_type(). "); } #endif @@ -350,7 +350,7 @@ SEXP _arrow_Array__infer_type(SEXP x_sexp){ // array_from_vector.cpp:964 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__from_vector(SEXP x, SEXP s_type); -SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ +RcppExport SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type x(x_sexp); Rcpp::traits::input_parameter::type s_type(s_type_sexp); @@ -358,7 +358,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ +RcppExport SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__from_vector(). "); } #endif @@ -366,7 +366,7 @@ SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ // array_from_vector.cpp:979 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__from_list(Rcpp::List chunks, SEXP s_type); -SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ +RcppExport SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type chunks(chunks_sexp); Rcpp::traits::input_parameter::type s_type(s_type_sexp); @@ -374,7 +374,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ +RcppExport SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__from_list(). "); } #endif @@ -382,14 +382,14 @@ SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ // arraydata.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ArrayData__get_type(const std::shared_ptr& x); -SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(ArrayData__get_type(x)); END_RCPP } #else -SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call ArrayData__get_type(). "); } #endif @@ -397,14 +397,14 @@ SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ // arraydata.cpp:31 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_length(const std::shared_ptr& x); -SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(ArrayData__get_length(x)); END_RCPP } #else -SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call ArrayData__get_length(). "); } #endif @@ -412,14 +412,14 @@ SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ // arraydata.cpp:36 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_null_count(const std::shared_ptr& x); -SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(ArrayData__get_null_count(x)); END_RCPP } #else -SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call ArrayData__get_null_count(). "); } #endif @@ -427,14 +427,14 @@ SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ // arraydata.cpp:41 #if defined(ARROW_R_WITH_ARROW) int ArrayData__get_offset(const std::shared_ptr& x); -SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(ArrayData__get_offset(x)); END_RCPP } #else -SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call ArrayData__get_offset(). "); } #endif @@ -442,14 +442,14 @@ SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ // arraydata.cpp:46 #if defined(ARROW_R_WITH_ARROW) List ArrayData__buffers(const std::shared_ptr& x); -SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(ArrayData__buffers(x)); END_RCPP } #else -SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ +RcppExport SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call ArrayData__buffers(). "); } #endif @@ -457,14 +457,14 @@ SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ // buffer.cpp:22 #if defined(ARROW_R_WITH_ARROW) bool Buffer__is_mutable(const std::shared_ptr& buffer); -SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); return Rcpp::wrap(Buffer__is_mutable(buffer)); END_RCPP } #else -SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call Buffer__is_mutable(). "); } #endif @@ -472,7 +472,7 @@ SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ // buffer.cpp:27 #if defined(ARROW_R_WITH_ARROW) void Buffer__ZeroPadding(const std::shared_ptr& buffer); -SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); Buffer__ZeroPadding(buffer); @@ -480,7 +480,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call Buffer__ZeroPadding(). "); } #endif @@ -488,14 +488,14 @@ SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ // buffer.cpp:32 #if defined(ARROW_R_WITH_ARROW) int64_t Buffer__capacity(const std::shared_ptr& buffer); -SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); return Rcpp::wrap(Buffer__capacity(buffer)); END_RCPP } #else -SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call Buffer__capacity(). "); } #endif @@ -503,14 +503,14 @@ SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ // buffer.cpp:37 #if defined(ARROW_R_WITH_ARROW) int64_t Buffer__size(const std::shared_ptr& buffer); -SEXP _arrow_Buffer__size(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__size(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); return Rcpp::wrap(Buffer__size(buffer)); END_RCPP } #else -SEXP _arrow_Buffer__size(SEXP buffer_sexp){ +RcppExport SEXP _arrow_Buffer__size(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call Buffer__size(). "); } #endif @@ -518,14 +518,14 @@ SEXP _arrow_Buffer__size(SEXP buffer_sexp){ // buffer.cpp:42 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr r___RBuffer__initialize(SEXP x); -SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ +RcppExport SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type x(x_sexp); return Rcpp::wrap(r___RBuffer__initialize(x)); END_RCPP } #else -SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ +RcppExport SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call r___RBuffer__initialize(). "); } #endif @@ -533,14 +533,14 @@ SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ // chunkedarray.cpp:25 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__length(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__length(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__length(). "); } #endif @@ -548,14 +548,14 @@ SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ // chunkedarray.cpp:30 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__null_count(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__null_count(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__null_count(). "); } #endif @@ -563,14 +563,14 @@ SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ // chunkedarray.cpp:35 #if defined(ARROW_R_WITH_ARROW) int ChunkedArray__num_chunks(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__num_chunks(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__num_chunks(). "); } #endif @@ -578,7 +578,7 @@ SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ // chunkedarray.cpp:40 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__chunk(const std::shared_ptr& chunked_array, int i); -SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -586,7 +586,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunk(). "); } #endif @@ -594,14 +594,14 @@ SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ // chunkedarray.cpp:46 #if defined(ARROW_R_WITH_ARROW) List ChunkedArray__chunks(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__chunks(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunks(). "); } #endif @@ -609,14 +609,14 @@ SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ // chunkedarray.cpp:51 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__type(const std::shared_ptr& chunked_array); -SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); return Rcpp::wrap(ChunkedArray__type(chunked_array)); END_RCPP } #else -SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ +RcppExport SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__type(). "); } #endif @@ -624,7 +624,7 @@ SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ // chunkedarray.cpp:57 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkArray__Slice1(const std::shared_ptr& chunked_array, int offset); -SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -632,7 +632,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice1(). "); } #endif @@ -640,7 +640,7 @@ SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ // chunkedarray.cpp:63 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkArray__Slice2(const std::shared_ptr& chunked_array, int offset, int length); -SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -649,7 +649,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice2(). "); } #endif @@ -657,14 +657,14 @@ SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP l // column.cpp:22 #if defined(ARROW_R_WITH_ARROW) int Column__length(const std::shared_ptr& column); -SEXP _arrow_Column__length(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__length(SEXP column_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type column(column_sexp); return Rcpp::wrap(Column__length(column)); END_RCPP } #else -SEXP _arrow_Column__length(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__length(SEXP column_sexp){ Rf_error("arrow C++ library not available. Cannot call Column__length(). "); } #endif @@ -672,14 +672,14 @@ SEXP _arrow_Column__length(SEXP column_sexp){ // column.cpp:27 #if defined(ARROW_R_WITH_ARROW) int Column__null_count(const std::shared_ptr& column); -SEXP _arrow_Column__null_count(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__null_count(SEXP column_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type column(column_sexp); return Rcpp::wrap(Column__null_count(column)); END_RCPP } #else -SEXP _arrow_Column__null_count(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__null_count(SEXP column_sexp){ Rf_error("arrow C++ library not available. Cannot call Column__null_count(). "); } #endif @@ -687,14 +687,14 @@ SEXP _arrow_Column__null_count(SEXP column_sexp){ // column.cpp:32 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Column__type(const std::shared_ptr& column); -SEXP _arrow_Column__type(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__type(SEXP column_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type column(column_sexp); return Rcpp::wrap(Column__type(column)); END_RCPP } #else -SEXP _arrow_Column__type(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__type(SEXP column_sexp){ Rf_error("arrow C++ library not available. Cannot call Column__type(). "); } #endif @@ -702,14 +702,14 @@ SEXP _arrow_Column__type(SEXP column_sexp){ // column.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Column__data(const std::shared_ptr& column); -SEXP _arrow_Column__data(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__data(SEXP column_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type column(column_sexp); return Rcpp::wrap(Column__data(column)); END_RCPP } #else -SEXP _arrow_Column__data(SEXP column_sexp){ +RcppExport SEXP _arrow_Column__data(SEXP column_sexp){ Rf_error("arrow C++ library not available. Cannot call Column__data(). "); } #endif @@ -717,14 +717,14 @@ SEXP _arrow_Column__data(SEXP column_sexp){ // compression.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr util___Codec__Create(arrow::Compression::type codec); -SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ +RcppExport SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type codec(codec_sexp); return Rcpp::wrap(util___Codec__Create(codec)); END_RCPP } #else -SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ +RcppExport SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ Rf_error("arrow C++ library not available. Cannot call util___Codec__Create(). "); } #endif @@ -732,7 +732,7 @@ SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ // compression.cpp:29 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___CompressedOutputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); -SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ +RcppExport SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type codec(codec_sexp); Rcpp::traits::input_parameter&>::type raw(raw_sexp); @@ -740,7 +740,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ +RcppExport SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ Rf_error("arrow C++ library not available. Cannot call io___CompressedOutputStream__Make(). "); } #endif @@ -748,7 +748,7 @@ SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ // compression.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___CompressedInputStream__Make(const std::unique_ptr& codec, const std::shared_ptr& raw); -SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ +RcppExport SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type codec(codec_sexp); Rcpp::traits::input_parameter&>::type raw(raw_sexp); @@ -756,7 +756,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ +RcppExport SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ Rf_error("arrow C++ library not available. Cannot call io___CompressedInputStream__Make(). "); } #endif @@ -764,7 +764,7 @@ SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ // compute.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr compute___CastOptions__initialize(bool allow_int_overflow, bool allow_time_truncate, bool allow_float_truncate); -SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ +RcppExport SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type allow_int_overflow(allow_int_overflow_sexp); Rcpp::traits::input_parameter::type allow_time_truncate(allow_time_truncate_sexp); @@ -773,7 +773,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ +RcppExport SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ Rf_error("arrow C++ library not available. Cannot call compute___CastOptions__initialize(). "); } #endif @@ -781,7 +781,7 @@ SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP // compute.cpp:32 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Array__cast(const std::shared_ptr& array, const std::shared_ptr& target_type, const std::shared_ptr& options); -SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type array(array_sexp); Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); @@ -790,7 +790,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call Array__cast(). "); } #endif @@ -798,7 +798,7 @@ SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sex // compute.cpp:43 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ChunkedArray__cast(const std::shared_ptr& chunked_array, const std::shared_ptr& target_type, const std::shared_ptr& options); -SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type chunked_array(chunked_array_sexp); Rcpp::traits::input_parameter&>::type target_type(target_type_sexp); @@ -807,7 +807,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call ChunkedArray__cast(). "); } #endif @@ -815,7 +815,7 @@ SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, S // compute.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__cast(const std::shared_ptr& batch, const std::shared_ptr& schema, const std::shared_ptr& options); -SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -824,7 +824,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__cast(). "); } #endif @@ -832,7 +832,7 @@ SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_se // compute.cpp:70 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__cast(const std::shared_ptr& table, const std::shared_ptr& schema, const std::shared_ptr& options); -SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type table(table_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -841,7 +841,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ +RcppExport SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__cast(). "); } #endif @@ -849,14 +849,14 @@ SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ // csv.cpp:25 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ReadOptions__initialize(List_ options); -SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type options(options_sexp); return Rcpp::wrap(csv___ReadOptions__initialize(options)); END_RCPP } #else -SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call csv___ReadOptions__initialize(). "); } #endif @@ -864,14 +864,14 @@ SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ // csv.cpp:36 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ParseOptions__initialize(List_ options); -SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type options(options_sexp); return Rcpp::wrap(csv___ParseOptions__initialize(options)); END_RCPP } #else -SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call csv___ParseOptions__initialize(). "); } #endif @@ -879,14 +879,14 @@ SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ // csv.cpp:51 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___ConvertOptions__initialize(List_ options); -SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type options(options_sexp); return Rcpp::wrap(csv___ConvertOptions__initialize(options)); END_RCPP } #else -SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ +RcppExport SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ Rf_error("arrow C++ library not available. Cannot call csv___ConvertOptions__initialize(). "); } #endif @@ -894,7 +894,7 @@ SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ // csv.cpp:60 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___TableReader__Make(const std::shared_ptr& input, const std::shared_ptr& read_options, const std::shared_ptr& parse_options, const std::shared_ptr& convert_options); -SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ +RcppExport SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type input(input_sexp); Rcpp::traits::input_parameter&>::type read_options(read_options_sexp); @@ -904,7 +904,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ +RcppExport SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Make(). "); } #endif @@ -912,14 +912,14 @@ SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEX // csv.cpp:73 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr csv___TableReader__Read(const std::shared_ptr& table_reader); -SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ +RcppExport SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type table_reader(table_reader_sexp); return Rcpp::wrap(csv___TableReader__Read(table_reader)); END_RCPP } #else -SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ +RcppExport SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Read(). "); } #endif @@ -927,14 +927,14 @@ SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ // datatype.cpp:27 #if defined(ARROW_R_WITH_ARROW) bool shared_ptr_is_null(SEXP xp); -SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ +RcppExport SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type xp(xp_sexp); return Rcpp::wrap(shared_ptr_is_null(xp)); END_RCPP } #else -SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ +RcppExport SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ Rf_error("arrow C++ library not available. Cannot call shared_ptr_is_null(). "); } #endif @@ -942,14 +942,14 @@ SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ // datatype.cpp:32 #if defined(ARROW_R_WITH_ARROW) bool unique_ptr_is_null(SEXP xp); -SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ +RcppExport SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type xp(xp_sexp); return Rcpp::wrap(unique_ptr_is_null(xp)); END_RCPP } #else -SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ +RcppExport SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ Rf_error("arrow C++ library not available. Cannot call unique_ptr_is_null(). "); } #endif @@ -957,13 +957,13 @@ SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ // datatype.cpp:37 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int8__initialize(); -SEXP _arrow_Int8__initialize(){ +RcppExport SEXP _arrow_Int8__initialize(){ BEGIN_RCPP return Rcpp::wrap(Int8__initialize()); END_RCPP } #else -SEXP _arrow_Int8__initialize(){ +RcppExport SEXP _arrow_Int8__initialize(){ Rf_error("arrow C++ library not available. Cannot call Int8__initialize(). "); } #endif @@ -971,13 +971,13 @@ SEXP _arrow_Int8__initialize(){ // datatype.cpp:40 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int16__initialize(); -SEXP _arrow_Int16__initialize(){ +RcppExport SEXP _arrow_Int16__initialize(){ BEGIN_RCPP return Rcpp::wrap(Int16__initialize()); END_RCPP } #else -SEXP _arrow_Int16__initialize(){ +RcppExport SEXP _arrow_Int16__initialize(){ Rf_error("arrow C++ library not available. Cannot call Int16__initialize(). "); } #endif @@ -985,13 +985,13 @@ SEXP _arrow_Int16__initialize(){ // datatype.cpp:43 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int32__initialize(); -SEXP _arrow_Int32__initialize(){ +RcppExport SEXP _arrow_Int32__initialize(){ BEGIN_RCPP return Rcpp::wrap(Int32__initialize()); END_RCPP } #else -SEXP _arrow_Int32__initialize(){ +RcppExport SEXP _arrow_Int32__initialize(){ Rf_error("arrow C++ library not available. Cannot call Int32__initialize(). "); } #endif @@ -999,13 +999,13 @@ SEXP _arrow_Int32__initialize(){ // datatype.cpp:46 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Int64__initialize(); -SEXP _arrow_Int64__initialize(){ +RcppExport SEXP _arrow_Int64__initialize(){ BEGIN_RCPP return Rcpp::wrap(Int64__initialize()); END_RCPP } #else -SEXP _arrow_Int64__initialize(){ +RcppExport SEXP _arrow_Int64__initialize(){ Rf_error("arrow C++ library not available. Cannot call Int64__initialize(). "); } #endif @@ -1013,13 +1013,13 @@ SEXP _arrow_Int64__initialize(){ // datatype.cpp:49 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt8__initialize(); -SEXP _arrow_UInt8__initialize(){ +RcppExport SEXP _arrow_UInt8__initialize(){ BEGIN_RCPP return Rcpp::wrap(UInt8__initialize()); END_RCPP } #else -SEXP _arrow_UInt8__initialize(){ +RcppExport SEXP _arrow_UInt8__initialize(){ Rf_error("arrow C++ library not available. Cannot call UInt8__initialize(). "); } #endif @@ -1027,13 +1027,13 @@ SEXP _arrow_UInt8__initialize(){ // datatype.cpp:52 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt16__initialize(); -SEXP _arrow_UInt16__initialize(){ +RcppExport SEXP _arrow_UInt16__initialize(){ BEGIN_RCPP return Rcpp::wrap(UInt16__initialize()); END_RCPP } #else -SEXP _arrow_UInt16__initialize(){ +RcppExport SEXP _arrow_UInt16__initialize(){ Rf_error("arrow C++ library not available. Cannot call UInt16__initialize(). "); } #endif @@ -1041,13 +1041,13 @@ SEXP _arrow_UInt16__initialize(){ // datatype.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt32__initialize(); -SEXP _arrow_UInt32__initialize(){ +RcppExport SEXP _arrow_UInt32__initialize(){ BEGIN_RCPP return Rcpp::wrap(UInt32__initialize()); END_RCPP } #else -SEXP _arrow_UInt32__initialize(){ +RcppExport SEXP _arrow_UInt32__initialize(){ Rf_error("arrow C++ library not available. Cannot call UInt32__initialize(). "); } #endif @@ -1055,13 +1055,13 @@ SEXP _arrow_UInt32__initialize(){ // datatype.cpp:58 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr UInt64__initialize(); -SEXP _arrow_UInt64__initialize(){ +RcppExport SEXP _arrow_UInt64__initialize(){ BEGIN_RCPP return Rcpp::wrap(UInt64__initialize()); END_RCPP } #else -SEXP _arrow_UInt64__initialize(){ +RcppExport SEXP _arrow_UInt64__initialize(){ Rf_error("arrow C++ library not available. Cannot call UInt64__initialize(). "); } #endif @@ -1069,13 +1069,13 @@ SEXP _arrow_UInt64__initialize(){ // datatype.cpp:61 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float16__initialize(); -SEXP _arrow_Float16__initialize(){ +RcppExport SEXP _arrow_Float16__initialize(){ BEGIN_RCPP return Rcpp::wrap(Float16__initialize()); END_RCPP } #else -SEXP _arrow_Float16__initialize(){ +RcppExport SEXP _arrow_Float16__initialize(){ Rf_error("arrow C++ library not available. Cannot call Float16__initialize(). "); } #endif @@ -1083,13 +1083,13 @@ SEXP _arrow_Float16__initialize(){ // datatype.cpp:64 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float32__initialize(); -SEXP _arrow_Float32__initialize(){ +RcppExport SEXP _arrow_Float32__initialize(){ BEGIN_RCPP return Rcpp::wrap(Float32__initialize()); END_RCPP } #else -SEXP _arrow_Float32__initialize(){ +RcppExport SEXP _arrow_Float32__initialize(){ Rf_error("arrow C++ library not available. Cannot call Float32__initialize(). "); } #endif @@ -1097,13 +1097,13 @@ SEXP _arrow_Float32__initialize(){ // datatype.cpp:67 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Float64__initialize(); -SEXP _arrow_Float64__initialize(){ +RcppExport SEXP _arrow_Float64__initialize(){ BEGIN_RCPP return Rcpp::wrap(Float64__initialize()); END_RCPP } #else -SEXP _arrow_Float64__initialize(){ +RcppExport SEXP _arrow_Float64__initialize(){ Rf_error("arrow C++ library not available. Cannot call Float64__initialize(). "); } #endif @@ -1111,13 +1111,13 @@ SEXP _arrow_Float64__initialize(){ // datatype.cpp:70 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Boolean__initialize(); -SEXP _arrow_Boolean__initialize(){ +RcppExport SEXP _arrow_Boolean__initialize(){ BEGIN_RCPP return Rcpp::wrap(Boolean__initialize()); END_RCPP } #else -SEXP _arrow_Boolean__initialize(){ +RcppExport SEXP _arrow_Boolean__initialize(){ Rf_error("arrow C++ library not available. Cannot call Boolean__initialize(). "); } #endif @@ -1125,13 +1125,13 @@ SEXP _arrow_Boolean__initialize(){ // datatype.cpp:73 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Utf8__initialize(); -SEXP _arrow_Utf8__initialize(){ +RcppExport SEXP _arrow_Utf8__initialize(){ BEGIN_RCPP return Rcpp::wrap(Utf8__initialize()); END_RCPP } #else -SEXP _arrow_Utf8__initialize(){ +RcppExport SEXP _arrow_Utf8__initialize(){ Rf_error("arrow C++ library not available. Cannot call Utf8__initialize(). "); } #endif @@ -1139,13 +1139,13 @@ SEXP _arrow_Utf8__initialize(){ // datatype.cpp:76 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Date32__initialize(); -SEXP _arrow_Date32__initialize(){ +RcppExport SEXP _arrow_Date32__initialize(){ BEGIN_RCPP return Rcpp::wrap(Date32__initialize()); END_RCPP } #else -SEXP _arrow_Date32__initialize(){ +RcppExport SEXP _arrow_Date32__initialize(){ Rf_error("arrow C++ library not available. Cannot call Date32__initialize(). "); } #endif @@ -1153,13 +1153,13 @@ SEXP _arrow_Date32__initialize(){ // datatype.cpp:79 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Date64__initialize(); -SEXP _arrow_Date64__initialize(){ +RcppExport SEXP _arrow_Date64__initialize(){ BEGIN_RCPP return Rcpp::wrap(Date64__initialize()); END_RCPP } #else -SEXP _arrow_Date64__initialize(){ +RcppExport SEXP _arrow_Date64__initialize(){ Rf_error("arrow C++ library not available. Cannot call Date64__initialize(). "); } #endif @@ -1167,13 +1167,13 @@ SEXP _arrow_Date64__initialize(){ // datatype.cpp:82 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Null__initialize(); -SEXP _arrow_Null__initialize(){ +RcppExport SEXP _arrow_Null__initialize(){ BEGIN_RCPP return Rcpp::wrap(Null__initialize()); END_RCPP } #else -SEXP _arrow_Null__initialize(){ +RcppExport SEXP _arrow_Null__initialize(){ Rf_error("arrow C++ library not available. Cannot call Null__initialize(). "); } #endif @@ -1181,7 +1181,7 @@ SEXP _arrow_Null__initialize(){ // datatype.cpp:85 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Decimal128Type__initialize(int32_t precision, int32_t scale); -SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ +RcppExport SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type precision(precision_sexp); Rcpp::traits::input_parameter::type scale(scale_sexp); @@ -1189,7 +1189,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ +RcppExport SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ Rf_error("arrow C++ library not available. Cannot call Decimal128Type__initialize(). "); } #endif @@ -1197,14 +1197,14 @@ SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ // datatype.cpp:91 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr FixedSizeBinary__initialize(int32_t byte_width); -SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ +RcppExport SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type byte_width(byte_width_sexp); return Rcpp::wrap(FixedSizeBinary__initialize(byte_width)); END_RCPP } #else -SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ +RcppExport SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ Rf_error("arrow C++ library not available. Cannot call FixedSizeBinary__initialize(). "); } #endif @@ -1212,14 +1212,14 @@ SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ // datatype.cpp:96 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Timestamp__initialize1(arrow::TimeUnit::type unit); -SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ +RcppExport SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type unit(unit_sexp); return Rcpp::wrap(Timestamp__initialize1(unit)); END_RCPP } #else -SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ +RcppExport SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize1(). "); } #endif @@ -1227,7 +1227,7 @@ SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ // datatype.cpp:101 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Timestamp__initialize2(arrow::TimeUnit::type unit, const std::string& timezone); -SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ +RcppExport SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type unit(unit_sexp); Rcpp::traits::input_parameter::type timezone(timezone_sexp); @@ -1235,7 +1235,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ +RcppExport SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize2(). "); } #endif @@ -1243,14 +1243,14 @@ SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ // datatype.cpp:107 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Time32__initialize(arrow::TimeUnit::type unit); -SEXP _arrow_Time32__initialize(SEXP unit_sexp){ +RcppExport SEXP _arrow_Time32__initialize(SEXP unit_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type unit(unit_sexp); return Rcpp::wrap(Time32__initialize(unit)); END_RCPP } #else -SEXP _arrow_Time32__initialize(SEXP unit_sexp){ +RcppExport SEXP _arrow_Time32__initialize(SEXP unit_sexp){ Rf_error("arrow C++ library not available. Cannot call Time32__initialize(). "); } #endif @@ -1258,14 +1258,14 @@ SEXP _arrow_Time32__initialize(SEXP unit_sexp){ // datatype.cpp:112 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Time64__initialize(arrow::TimeUnit::type unit); -SEXP _arrow_Time64__initialize(SEXP unit_sexp){ +RcppExport SEXP _arrow_Time64__initialize(SEXP unit_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type unit(unit_sexp); return Rcpp::wrap(Time64__initialize(unit)); END_RCPP } #else -SEXP _arrow_Time64__initialize(SEXP unit_sexp){ +RcppExport SEXP _arrow_Time64__initialize(SEXP unit_sexp){ Rf_error("arrow C++ library not available. Cannot call Time64__initialize(). "); } #endif @@ -1273,14 +1273,14 @@ SEXP _arrow_Time64__initialize(SEXP unit_sexp){ // datatype.cpp:117 #if defined(ARROW_R_WITH_ARROW) SEXP list__(SEXP x); -SEXP _arrow_list__(SEXP x_sexp){ +RcppExport SEXP _arrow_list__(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type x(x_sexp); return Rcpp::wrap(list__(x)); END_RCPP } #else -SEXP _arrow_list__(SEXP x_sexp){ +RcppExport SEXP _arrow_list__(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call list__(). "); } #endif @@ -1288,14 +1288,14 @@ SEXP _arrow_list__(SEXP x_sexp){ // datatype.cpp:133 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr struct_(List fields); -SEXP _arrow_struct_(SEXP fields_sexp){ +RcppExport SEXP _arrow_struct_(SEXP fields_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type fields(fields_sexp); return Rcpp::wrap(struct_(fields)); END_RCPP } #else -SEXP _arrow_struct_(SEXP fields_sexp){ +RcppExport SEXP _arrow_struct_(SEXP fields_sexp){ Rf_error("arrow C++ library not available. Cannot call struct_(). "); } #endif @@ -1303,14 +1303,14 @@ SEXP _arrow_struct_(SEXP fields_sexp){ // datatype.cpp:138 #if defined(ARROW_R_WITH_ARROW) std::string DataType__ToString(const std::shared_ptr& type); -SEXP _arrow_DataType__ToString(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__ToString(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DataType__ToString(type)); END_RCPP } #else -SEXP _arrow_DataType__ToString(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__ToString(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__ToString(). "); } #endif @@ -1318,14 +1318,14 @@ SEXP _arrow_DataType__ToString(SEXP type_sexp){ // datatype.cpp:143 #if defined(ARROW_R_WITH_ARROW) std::string DataType__name(const std::shared_ptr& type); -SEXP _arrow_DataType__name(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__name(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DataType__name(type)); END_RCPP } #else -SEXP _arrow_DataType__name(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__name(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__name(). "); } #endif @@ -1333,7 +1333,7 @@ SEXP _arrow_DataType__name(SEXP type_sexp){ // datatype.cpp:148 #if defined(ARROW_R_WITH_ARROW) bool DataType__Equals(const std::shared_ptr& lhs, const std::shared_ptr& rhs); -SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type lhs(lhs_sexp); Rcpp::traits::input_parameter&>::type rhs(rhs_sexp); @@ -1341,7 +1341,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ +RcppExport SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__Equals(). "); } #endif @@ -1349,14 +1349,14 @@ SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ // datatype.cpp:154 #if defined(ARROW_R_WITH_ARROW) int DataType__num_children(const std::shared_ptr& type); -SEXP _arrow_DataType__num_children(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__num_children(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DataType__num_children(type)); END_RCPP } #else -SEXP _arrow_DataType__num_children(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__num_children(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__num_children(). "); } #endif @@ -1364,14 +1364,14 @@ SEXP _arrow_DataType__num_children(SEXP type_sexp){ // datatype.cpp:159 #if defined(ARROW_R_WITH_ARROW) List DataType__children_pointer(const std::shared_ptr& type); -SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DataType__children_pointer(type)); END_RCPP } #else -SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__children_pointer(). "); } #endif @@ -1379,14 +1379,14 @@ SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ // datatype.cpp:164 #if defined(ARROW_R_WITH_ARROW) arrow::Type::type DataType__id(const std::shared_ptr& type); -SEXP _arrow_DataType__id(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__id(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DataType__id(type)); END_RCPP } #else -SEXP _arrow_DataType__id(SEXP type_sexp){ +RcppExport SEXP _arrow_DataType__id(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DataType__id(). "); } #endif @@ -1394,14 +1394,14 @@ SEXP _arrow_DataType__id(SEXP type_sexp){ // datatype.cpp:169 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr schema_(List fields); -SEXP _arrow_schema_(SEXP fields_sexp){ +RcppExport SEXP _arrow_schema_(SEXP fields_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type fields(fields_sexp); return Rcpp::wrap(schema_(fields)); END_RCPP } #else -SEXP _arrow_schema_(SEXP fields_sexp){ +RcppExport SEXP _arrow_schema_(SEXP fields_sexp){ Rf_error("arrow C++ library not available. Cannot call schema_(). "); } #endif @@ -1409,14 +1409,14 @@ SEXP _arrow_schema_(SEXP fields_sexp){ // datatype.cpp:174 #if defined(ARROW_R_WITH_ARROW) std::string Schema__ToString(const std::shared_ptr& s); -SEXP _arrow_Schema__ToString(SEXP s_sexp){ +RcppExport SEXP _arrow_Schema__ToString(SEXP s_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type s(s_sexp); return Rcpp::wrap(Schema__ToString(s)); END_RCPP } #else -SEXP _arrow_Schema__ToString(SEXP s_sexp){ +RcppExport SEXP _arrow_Schema__ToString(SEXP s_sexp){ Rf_error("arrow C++ library not available. Cannot call Schema__ToString(). "); } #endif @@ -1424,14 +1424,14 @@ SEXP _arrow_Schema__ToString(SEXP s_sexp){ // datatype.cpp:179 #if defined(ARROW_R_WITH_ARROW) int Schema__num_fields(const std::shared_ptr& s); -SEXP _arrow_Schema__num_fields(SEXP s_sexp){ +RcppExport SEXP _arrow_Schema__num_fields(SEXP s_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type s(s_sexp); return Rcpp::wrap(Schema__num_fields(s)); END_RCPP } #else -SEXP _arrow_Schema__num_fields(SEXP s_sexp){ +RcppExport SEXP _arrow_Schema__num_fields(SEXP s_sexp){ Rf_error("arrow C++ library not available. Cannot call Schema__num_fields(). "); } #endif @@ -1439,7 +1439,7 @@ SEXP _arrow_Schema__num_fields(SEXP s_sexp){ // datatype.cpp:184 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Schema__field(const std::shared_ptr& s, int i); -SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type s(s_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -1447,7 +1447,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call Schema__field(). "); } #endif @@ -1455,14 +1455,14 @@ SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ // datatype.cpp:194 #if defined(ARROW_R_WITH_ARROW) CharacterVector Schema__names(const std::shared_ptr& schema); -SEXP _arrow_Schema__names(SEXP schema_sexp){ +RcppExport SEXP _arrow_Schema__names(SEXP schema_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type schema(schema_sexp); return Rcpp::wrap(Schema__names(schema)); END_RCPP } #else -SEXP _arrow_Schema__names(SEXP schema_sexp){ +RcppExport SEXP _arrow_Schema__names(SEXP schema_sexp){ Rf_error("arrow C++ library not available. Cannot call Schema__names(). "); } #endif @@ -1470,14 +1470,14 @@ SEXP _arrow_Schema__names(SEXP schema_sexp){ // datatype.cpp:202 #if defined(ARROW_R_WITH_ARROW) std::string ListType__ToString(const std::shared_ptr& type); -SEXP _arrow_ListType__ToString(SEXP type_sexp){ +RcppExport SEXP _arrow_ListType__ToString(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(ListType__ToString(type)); END_RCPP } #else -SEXP _arrow_ListType__ToString(SEXP type_sexp){ +RcppExport SEXP _arrow_ListType__ToString(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call ListType__ToString(). "); } #endif @@ -1485,14 +1485,14 @@ SEXP _arrow_ListType__ToString(SEXP type_sexp){ // datatype.cpp:207 #if defined(ARROW_R_WITH_ARROW) int FixedWidthType__bit_width(const std::shared_ptr& type); -SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ +RcppExport SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(FixedWidthType__bit_width(type)); END_RCPP } #else -SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ +RcppExport SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call FixedWidthType__bit_width(). "); } #endif @@ -1500,14 +1500,14 @@ SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ // datatype.cpp:212 #if defined(ARROW_R_WITH_ARROW) arrow::DateUnit DateType__unit(const std::shared_ptr& type); -SEXP _arrow_DateType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_DateType__unit(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DateType__unit(type)); END_RCPP } #else -SEXP _arrow_DateType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_DateType__unit(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DateType__unit(). "); } #endif @@ -1515,14 +1515,14 @@ SEXP _arrow_DateType__unit(SEXP type_sexp){ // datatype.cpp:217 #if defined(ARROW_R_WITH_ARROW) arrow::TimeUnit::type TimeType__unit(const std::shared_ptr& type); -SEXP _arrow_TimeType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_TimeType__unit(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(TimeType__unit(type)); END_RCPP } #else -SEXP _arrow_TimeType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_TimeType__unit(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call TimeType__unit(). "); } #endif @@ -1530,14 +1530,14 @@ SEXP _arrow_TimeType__unit(SEXP type_sexp){ // datatype.cpp:222 #if defined(ARROW_R_WITH_ARROW) int32_t DecimalType__precision(const std::shared_ptr& type); -SEXP _arrow_DecimalType__precision(SEXP type_sexp){ +RcppExport SEXP _arrow_DecimalType__precision(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DecimalType__precision(type)); END_RCPP } #else -SEXP _arrow_DecimalType__precision(SEXP type_sexp){ +RcppExport SEXP _arrow_DecimalType__precision(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DecimalType__precision(). "); } #endif @@ -1545,14 +1545,14 @@ SEXP _arrow_DecimalType__precision(SEXP type_sexp){ // datatype.cpp:227 #if defined(ARROW_R_WITH_ARROW) int32_t DecimalType__scale(const std::shared_ptr& type); -SEXP _arrow_DecimalType__scale(SEXP type_sexp){ +RcppExport SEXP _arrow_DecimalType__scale(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DecimalType__scale(type)); END_RCPP } #else -SEXP _arrow_DecimalType__scale(SEXP type_sexp){ +RcppExport SEXP _arrow_DecimalType__scale(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DecimalType__scale(). "); } #endif @@ -1560,14 +1560,14 @@ SEXP _arrow_DecimalType__scale(SEXP type_sexp){ // datatype.cpp:232 #if defined(ARROW_R_WITH_ARROW) std::string TimestampType__timezone(const std::shared_ptr& type); -SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ +RcppExport SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(TimestampType__timezone(type)); END_RCPP } #else -SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ +RcppExport SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call TimestampType__timezone(). "); } #endif @@ -1575,14 +1575,14 @@ SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ // datatype.cpp:237 #if defined(ARROW_R_WITH_ARROW) arrow::TimeUnit::type TimestampType__unit(const std::shared_ptr& type); -SEXP _arrow_TimestampType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_TimestampType__unit(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(TimestampType__unit(type)); END_RCPP } #else -SEXP _arrow_TimestampType__unit(SEXP type_sexp){ +RcppExport SEXP _arrow_TimestampType__unit(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call TimestampType__unit(). "); } #endif @@ -1590,7 +1590,7 @@ SEXP _arrow_TimestampType__unit(SEXP type_sexp){ // datatype.cpp:243 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__initialize(const std::shared_ptr& index_type, const std::shared_ptr& value_type, bool ordered); -SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ +RcppExport SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type index_type(index_type_sexp); Rcpp::traits::input_parameter&>::type value_type(value_type_sexp); @@ -1599,7 +1599,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ +RcppExport SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryType__initialize(). "); } #endif @@ -1607,14 +1607,14 @@ SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sex // datatype.cpp:250 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__index_type(const std::shared_ptr& type); -SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DictionaryType__index_type(type)); END_RCPP } #else -SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryType__index_type(). "); } #endif @@ -1622,14 +1622,14 @@ SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ // datatype.cpp:256 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr DictionaryType__value_type(const std::shared_ptr& type); -SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DictionaryType__value_type(type)); END_RCPP } #else -SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryType__value_type(). "); } #endif @@ -1637,14 +1637,14 @@ SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ // datatype.cpp:262 #if defined(ARROW_R_WITH_ARROW) std::string DictionaryType__name(const std::shared_ptr& type); -SEXP _arrow_DictionaryType__name(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__name(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DictionaryType__name(type)); END_RCPP } #else -SEXP _arrow_DictionaryType__name(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__name(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryType__name(). "); } #endif @@ -1652,14 +1652,14 @@ SEXP _arrow_DictionaryType__name(SEXP type_sexp){ // datatype.cpp:267 #if defined(ARROW_R_WITH_ARROW) bool DictionaryType__ordered(const std::shared_ptr& type); -SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type type(type_sexp); return Rcpp::wrap(DictionaryType__ordered(type)); END_RCPP } #else -SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ +RcppExport SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ Rf_error("arrow C++ library not available. Cannot call DictionaryType__ordered(). "); } #endif @@ -1667,7 +1667,7 @@ SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ // feather.cpp:24 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__SetDescription(const std::unique_ptr& writer, const std::string& description); -SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type writer(writer_sexp); Rcpp::traits::input_parameter::type description(description_sexp); @@ -1676,7 +1676,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetDescription(). "); } #endif @@ -1684,7 +1684,7 @@ SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP d // feather.cpp:31 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__SetNumRows(const std::unique_ptr& writer, int64_t num_rows); -SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type writer(writer_sexp); Rcpp::traits::input_parameter::type num_rows(num_rows_sexp); @@ -1693,7 +1693,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetNumRows(). "); } #endif @@ -1701,7 +1701,7 @@ SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_r // feather.cpp:37 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__Append(const std::unique_ptr& writer, const std::string& name, const std::shared_ptr& values); -SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type writer(writer_sexp); Rcpp::traits::input_parameter::type name(name_sexp); @@ -1711,7 +1711,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Append(). "); } #endif @@ -1719,7 +1719,7 @@ SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp // feather.cpp:44 #if defined(ARROW_R_WITH_ARROW) void ipc___feather___TableWriter__Finalize(const std::unique_ptr& writer); -SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type writer(writer_sexp); ipc___feather___TableWriter__Finalize(writer); @@ -1727,7 +1727,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Finalize(). "); } #endif @@ -1735,14 +1735,14 @@ SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ // feather.cpp:50 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___feather___TableWriter__Open(const std::shared_ptr& stream); -SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___feather___TableWriter__Open(stream)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Open(). "); } #endif @@ -1750,7 +1750,7 @@ SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ // feather.cpp:58 #if defined(ARROW_R_WITH_ARROW) void ipc___TableWriter__RecordBatch__WriteFeather(const std::unique_ptr& writer, const std::shared_ptr& batch); -SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type writer(writer_sexp); Rcpp::traits::input_parameter&>::type batch(batch_sexp); @@ -1759,7 +1759,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___TableWriter__RecordBatch__WriteFeather(). "); } #endif @@ -1767,14 +1767,14 @@ SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP // feather.cpp:72 #if defined(ARROW_R_WITH_ARROW) std::string ipc___feather___TableReader__GetDescription(const std::unique_ptr& reader); -SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___feather___TableReader__GetDescription(reader)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetDescription(). "); } #endif @@ -1782,14 +1782,14 @@ SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ // feather.cpp:78 #if defined(ARROW_R_WITH_ARROW) bool ipc___feather___TableReader__HasDescription(const std::unique_ptr& reader); -SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___feather___TableReader__HasDescription(reader)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__HasDescription(). "); } #endif @@ -1797,14 +1797,14 @@ SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ // feather.cpp:84 #if defined(ARROW_R_WITH_ARROW) int ipc___feather___TableReader__version(const std::unique_ptr& reader); -SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___feather___TableReader__version(reader)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__version(). "); } #endif @@ -1812,14 +1812,14 @@ SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ // feather.cpp:90 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___feather___TableReader__num_rows(const std::unique_ptr& reader); -SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___feather___TableReader__num_rows(reader)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_rows(). "); } #endif @@ -1827,14 +1827,14 @@ SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ // feather.cpp:96 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___feather___TableReader__num_columns(const std::unique_ptr& reader); -SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___feather___TableReader__num_columns(reader)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_columns(). "); } #endif @@ -1842,7 +1842,7 @@ SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ // feather.cpp:102 #if defined(ARROW_R_WITH_ARROW) std::string ipc___feather___TableReader__GetColumnName(const std::unique_ptr& reader, int i); -SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -1850,7 +1850,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumnName(). "); } #endif @@ -1858,7 +1858,7 @@ SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_ // feather.cpp:108 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___feather___TableReader__GetColumn(const std::unique_ptr& reader, int i); -SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -1866,7 +1866,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumn(). "); } #endif @@ -1874,7 +1874,7 @@ SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp // feather.cpp:116 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___feather___TableReader__Read(const std::unique_ptr& reader, SEXP columns); -SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); Rcpp::traits::input_parameter::type columns(columns_sexp); @@ -1882,7 +1882,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Read(). "); } #endif @@ -1890,14 +1890,14 @@ SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sex // feather.cpp:152 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___feather___TableReader__Open(const std::shared_ptr& stream); -SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___feather___TableReader__Open(stream)); END_RCPP } #else -SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Open(). "); } #endif @@ -1905,7 +1905,7 @@ SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ // field.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Field__initialize(const std::string& name, const std::shared_ptr& field, bool nullable); -SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ +RcppExport SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type name(name_sexp); Rcpp::traits::input_parameter&>::type field(field_sexp); @@ -1914,7 +1914,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ +RcppExport SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__initialize(). "); } #endif @@ -1922,14 +1922,14 @@ SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sex // field.cpp:29 #if defined(ARROW_R_WITH_ARROW) std::string Field__ToString(const std::shared_ptr& field); -SEXP _arrow_Field__ToString(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__ToString(SEXP field_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type field(field_sexp); return Rcpp::wrap(Field__ToString(field)); END_RCPP } #else -SEXP _arrow_Field__ToString(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__ToString(SEXP field_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__ToString(). "); } #endif @@ -1937,14 +1937,14 @@ SEXP _arrow_Field__ToString(SEXP field_sexp){ // field.cpp:34 #if defined(ARROW_R_WITH_ARROW) std::string Field__name(const std::shared_ptr& field); -SEXP _arrow_Field__name(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__name(SEXP field_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type field(field_sexp); return Rcpp::wrap(Field__name(field)); END_RCPP } #else -SEXP _arrow_Field__name(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__name(SEXP field_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__name(). "); } #endif @@ -1952,7 +1952,7 @@ SEXP _arrow_Field__name(SEXP field_sexp){ // field.cpp:39 #if defined(ARROW_R_WITH_ARROW) bool Field__Equals(const std::shared_ptr& field, const std::shared_ptr& other); -SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ +RcppExport SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type field(field_sexp); Rcpp::traits::input_parameter&>::type other(other_sexp); @@ -1960,7 +1960,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ +RcppExport SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__Equals(). "); } #endif @@ -1968,14 +1968,14 @@ SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ // field.cpp:45 #if defined(ARROW_R_WITH_ARROW) bool Field__nullable(const std::shared_ptr& field); -SEXP _arrow_Field__nullable(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__nullable(SEXP field_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type field(field_sexp); return Rcpp::wrap(Field__nullable(field)); END_RCPP } #else -SEXP _arrow_Field__nullable(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__nullable(SEXP field_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__nullable(). "); } #endif @@ -1983,14 +1983,14 @@ SEXP _arrow_Field__nullable(SEXP field_sexp){ // field.cpp:50 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Field__type(const std::shared_ptr& field); -SEXP _arrow_Field__type(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__type(SEXP field_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type field(field_sexp); return Rcpp::wrap(Field__type(field)); END_RCPP } #else -SEXP _arrow_Field__type(SEXP field_sexp){ +RcppExport SEXP _arrow_Field__type(SEXP field_sexp){ Rf_error("arrow C++ library not available. Cannot call Field__type(). "); } #endif @@ -1998,7 +1998,7 @@ SEXP _arrow_Field__type(SEXP field_sexp){ // io.cpp:26 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___Readable__Read(const std::shared_ptr& x, int64_t nbytes); -SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ +RcppExport SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter::type nbytes(nbytes_sexp); @@ -2006,7 +2006,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ +RcppExport SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ Rf_error("arrow C++ library not available. Cannot call io___Readable__Read(). "); } #endif @@ -2014,7 +2014,7 @@ SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ // io.cpp:36 #if defined(ARROW_R_WITH_ARROW) void io___InputStream__Close(const std::shared_ptr& x); -SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ +RcppExport SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); io___InputStream__Close(x); @@ -2022,7 +2022,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ +RcppExport SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call io___InputStream__Close(). "); } #endif @@ -2030,7 +2030,7 @@ SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ // io.cpp:43 #if defined(ARROW_R_WITH_ARROW) void io___OutputStream__Close(const std::shared_ptr& x); -SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ +RcppExport SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); io___OutputStream__Close(x); @@ -2038,7 +2038,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ +RcppExport SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Close(). "); } #endif @@ -2046,14 +2046,14 @@ SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ // io.cpp:50 #if defined(ARROW_R_WITH_ARROW) int64_t io___RandomAccessFile__GetSize(const std::shared_ptr& x); -SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(io___RandomAccessFile__GetSize(x)); END_RCPP } #else -SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__GetSize(). "); } #endif @@ -2061,14 +2061,14 @@ SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ // io.cpp:58 #if defined(ARROW_R_WITH_ARROW) bool io___RandomAccessFile__supports_zero_copy(const std::shared_ptr& x); -SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(io___RandomAccessFile__supports_zero_copy(x)); END_RCPP } #else -SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__supports_zero_copy(). "); } #endif @@ -2076,7 +2076,7 @@ SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ // io.cpp:64 #if defined(ARROW_R_WITH_ARROW) void io___RandomAccessFile__Seek(const std::shared_ptr& x, int64_t position); -SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter::type position(position_sexp); @@ -2085,7 +2085,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Seek(). "); } #endif @@ -2093,14 +2093,14 @@ SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ // io.cpp:70 #if defined(ARROW_R_WITH_ARROW) int64_t io___RandomAccessFile__Tell(const std::shared_ptr& x); -SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(io___RandomAccessFile__Tell(x)); END_RCPP } #else -SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ +RcppExport SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Tell(). "); } #endif @@ -2108,7 +2108,7 @@ SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ // io.cpp:80 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MemoryMappedFile__Create(const std::string& path, int64_t size); -SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type path(path_sexp); Rcpp::traits::input_parameter::type size(size_sexp); @@ -2116,7 +2116,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Create(). "); } #endif @@ -2124,7 +2124,7 @@ SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ // io.cpp:88 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MemoryMappedFile__Open(const std::string& path, arrow::io::FileMode::type mode); -SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type path(path_sexp); Rcpp::traits::input_parameter::type mode(mode_sexp); @@ -2132,7 +2132,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Open(). "); } #endif @@ -2140,7 +2140,7 @@ SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ // io.cpp:96 #if defined(ARROW_R_WITH_ARROW) void io___MemoryMappedFile__Resize(const std::shared_ptr& x, int64_t size); -SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter::type size(size_sexp); @@ -2149,7 +2149,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ +RcppExport SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Resize(). "); } #endif @@ -2157,14 +2157,14 @@ SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ // io.cpp:104 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___ReadableFile__Open(const std::string& path); -SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ +RcppExport SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type path(path_sexp); return Rcpp::wrap(io___ReadableFile__Open(path)); END_RCPP } #else -SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ +RcppExport SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ Rf_error("arrow C++ library not available. Cannot call io___ReadableFile__Open(). "); } #endif @@ -2172,14 +2172,14 @@ SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ // io.cpp:114 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferReader__initialize(const std::shared_ptr& buffer); -SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ +RcppExport SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); return Rcpp::wrap(io___BufferReader__initialize(buffer)); END_RCPP } #else -SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ +RcppExport SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferReader__initialize(). "); } #endif @@ -2187,7 +2187,7 @@ SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ // io.cpp:122 #if defined(ARROW_R_WITH_ARROW) void io___Writable__write(const std::shared_ptr& stream, const std::shared_ptr& buf); -SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ +RcppExport SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); Rcpp::traits::input_parameter&>::type buf(buf_sexp); @@ -2196,7 +2196,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ +RcppExport SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ Rf_error("arrow C++ library not available. Cannot call io___Writable__write(). "); } #endif @@ -2204,14 +2204,14 @@ SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ // io.cpp:130 #if defined(ARROW_R_WITH_ARROW) int64_t io___OutputStream__Tell(const std::shared_ptr& stream); -SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(io___OutputStream__Tell(stream)); END_RCPP } #else -SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Tell(). "); } #endif @@ -2219,14 +2219,14 @@ SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ // io.cpp:139 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___FileOutputStream__Open(const std::string& path); -SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ +RcppExport SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type path(path_sexp); return Rcpp::wrap(io___FileOutputStream__Open(path)); END_RCPP } #else -SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ +RcppExport SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ Rf_error("arrow C++ library not available. Cannot call io___FileOutputStream__Open(). "); } #endif @@ -2234,14 +2234,14 @@ SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ // io.cpp:149 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferOutputStream__Create(int64_t initial_capacity); -SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type initial_capacity(initial_capacity_sexp); return Rcpp::wrap(io___BufferOutputStream__Create(initial_capacity)); END_RCPP } #else -SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Create(). "); } #endif @@ -2249,14 +2249,14 @@ SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ // io.cpp:158 #if defined(ARROW_R_WITH_ARROW) int64_t io___BufferOutputStream__capacity(const std::shared_ptr& stream); -SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(io___BufferOutputStream__capacity(stream)); END_RCPP } #else -SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__capacity(). "); } #endif @@ -2264,14 +2264,14 @@ SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ // io.cpp:164 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___BufferOutputStream__Finish(const std::shared_ptr& stream); -SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(io___BufferOutputStream__Finish(stream)); END_RCPP } #else -SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Finish(). "); } #endif @@ -2279,14 +2279,14 @@ SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ // io.cpp:172 #if defined(ARROW_R_WITH_ARROW) int64_t io___BufferOutputStream__Tell(const std::shared_ptr& stream); -SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(io___BufferOutputStream__Tell(stream)); END_RCPP } #else -SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Tell(). "); } #endif @@ -2294,7 +2294,7 @@ SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ // io.cpp:180 #if defined(ARROW_R_WITH_ARROW) void io___BufferOutputStream__Write(const std::shared_ptr& stream, RawVector_ bytes); -SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); Rcpp::traits::input_parameter::type bytes(bytes_sexp); @@ -2303,7 +2303,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ +RcppExport SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Write(). "); } #endif @@ -2311,13 +2311,13 @@ SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ // io.cpp:188 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___MockOutputStream__initialize(); -SEXP _arrow_io___MockOutputStream__initialize(){ +RcppExport SEXP _arrow_io___MockOutputStream__initialize(){ BEGIN_RCPP return Rcpp::wrap(io___MockOutputStream__initialize()); END_RCPP } #else -SEXP _arrow_io___MockOutputStream__initialize(){ +RcppExport SEXP _arrow_io___MockOutputStream__initialize(){ Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__initialize(). "); } #endif @@ -2325,14 +2325,14 @@ SEXP _arrow_io___MockOutputStream__initialize(){ // io.cpp:193 #if defined(ARROW_R_WITH_ARROW) int64_t io___MockOutputStream__GetExtentBytesWritten(const std::shared_ptr& stream); -SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(io___MockOutputStream__GetExtentBytesWritten(stream)); END_RCPP } #else -SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ +RcppExport SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__GetExtentBytesWritten(). "); } #endif @@ -2340,14 +2340,14 @@ SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ // io.cpp:201 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr io___FixedSizeBufferWriter__initialize(const std::shared_ptr& buffer); -SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ +RcppExport SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type buffer(buffer_sexp); return Rcpp::wrap(io___FixedSizeBufferWriter__initialize(buffer)); END_RCPP } #else -SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ +RcppExport SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ Rf_error("arrow C++ library not available. Cannot call io___FixedSizeBufferWriter__initialize(). "); } #endif @@ -2355,13 +2355,13 @@ SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ // memorypool.cpp:21 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr MemoryPool__default(); -SEXP _arrow_MemoryPool__default(){ +RcppExport SEXP _arrow_MemoryPool__default(){ BEGIN_RCPP return Rcpp::wrap(MemoryPool__default()); END_RCPP } #else -SEXP _arrow_MemoryPool__default(){ +RcppExport SEXP _arrow_MemoryPool__default(){ Rf_error("arrow C++ library not available. Cannot call MemoryPool__default(). "); } #endif @@ -2369,14 +2369,14 @@ SEXP _arrow_MemoryPool__default(){ // memorypool.cpp:27 #if defined(ARROW_R_WITH_ARROW) int MemoryPool__bytes_allocated(const std::shared_ptr& pool); -SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ +RcppExport SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type pool(pool_sexp); return Rcpp::wrap(MemoryPool__bytes_allocated(pool)); END_RCPP } #else -SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ +RcppExport SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ Rf_error("arrow C++ library not available. Cannot call MemoryPool__bytes_allocated(). "); } #endif @@ -2384,14 +2384,14 @@ SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ // memorypool.cpp:32 #if defined(ARROW_R_WITH_ARROW) int MemoryPool__max_memory(const std::shared_ptr& pool); -SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ +RcppExport SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type pool(pool_sexp); return Rcpp::wrap(MemoryPool__max_memory(pool)); END_RCPP } #else -SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ +RcppExport SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ Rf_error("arrow C++ library not available. Cannot call MemoryPool__max_memory(). "); } #endif @@ -2399,14 +2399,14 @@ SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ // message.cpp:22 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___Message__body_length(const std::unique_ptr& message); -SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); return Rcpp::wrap(ipc___Message__body_length(message)); END_RCPP } #else -SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__body_length(). "); } #endif @@ -2414,14 +2414,14 @@ SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ // message.cpp:27 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___Message__metadata(const std::unique_ptr& message); -SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); return Rcpp::wrap(ipc___Message__metadata(message)); END_RCPP } #else -SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__metadata(). "); } #endif @@ -2429,14 +2429,14 @@ SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ // message.cpp:33 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___Message__body(const std::unique_ptr& message); -SEXP _arrow_ipc___Message__body(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__body(SEXP message_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); return Rcpp::wrap(ipc___Message__body(message)); END_RCPP } #else -SEXP _arrow_ipc___Message__body(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__body(SEXP message_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__body(). "); } #endif @@ -2444,14 +2444,14 @@ SEXP _arrow_ipc___Message__body(SEXP message_sexp){ // message.cpp:39 #if defined(ARROW_R_WITH_ARROW) int64_t ipc___Message__Verify(const std::unique_ptr& message); -SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); return Rcpp::wrap(ipc___Message__Verify(message)); END_RCPP } #else -SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__Verify(). "); } #endif @@ -2459,14 +2459,14 @@ SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ // message.cpp:44 #if defined(ARROW_R_WITH_ARROW) arrow::ipc::Message::Type ipc___Message__type(const std::unique_ptr& message); -SEXP _arrow_ipc___Message__type(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__type(SEXP message_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); return Rcpp::wrap(ipc___Message__type(message)); END_RCPP } #else -SEXP _arrow_ipc___Message__type(SEXP message_sexp){ +RcppExport SEXP _arrow_ipc___Message__type(SEXP message_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__type(). "); } #endif @@ -2474,7 +2474,7 @@ SEXP _arrow_ipc___Message__type(SEXP message_sexp){ // message.cpp:50 #if defined(ARROW_R_WITH_ARROW) bool ipc___Message__Equals(const std::unique_ptr& x, const std::unique_ptr& y); -SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ +RcppExport SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); Rcpp::traits::input_parameter&>::type y(y_sexp); @@ -2482,7 +2482,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ +RcppExport SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___Message__Equals(). "); } #endif @@ -2490,7 +2490,7 @@ SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ // message.cpp:56 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadRecordBatch__Message__Schema(const std::unique_ptr& message, const std::shared_ptr& schema); -SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type message(message_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -2498,7 +2498,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__Message__Schema(). "); } #endif @@ -2506,14 +2506,14 @@ SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schem // message.cpp:68 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadSchema_InputStream(const std::shared_ptr& stream); -SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___ReadSchema_InputStream(stream)); END_RCPP } #else -SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___ReadSchema_InputStream(). "); } #endif @@ -2521,14 +2521,14 @@ SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ // message.cpp:80 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___MessageReader__Open(const std::shared_ptr& stream); -SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___MessageReader__Open(stream)); END_RCPP } #else -SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__Open(). "); } #endif @@ -2536,14 +2536,14 @@ SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ // message.cpp:86 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___MessageReader__ReadNextMessage(const std::unique_ptr& reader); -SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___MessageReader__ReadNextMessage(reader)); END_RCPP } #else -SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__ReadNextMessage(). "); } #endif @@ -2551,14 +2551,14 @@ SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ // message.cpp:94 #if defined(ARROW_R_WITH_ARROW) std::unique_ptr ipc___ReadMessage(const std::shared_ptr& stream); -SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___ReadMessage(stream)); END_RCPP } #else -SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___ReadMessage(). "); } #endif @@ -2566,14 +2566,14 @@ SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ // parquet.cpp:28 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr read_parquet_file(std::string filename); -SEXP _arrow_read_parquet_file(SEXP filename_sexp){ +RcppExport SEXP _arrow_read_parquet_file(SEXP filename_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type filename(filename_sexp); return Rcpp::wrap(read_parquet_file(filename)); END_RCPP } #else -SEXP _arrow_read_parquet_file(SEXP filename_sexp){ +RcppExport SEXP _arrow_read_parquet_file(SEXP filename_sexp){ Rf_error("arrow C++ library not available. Cannot call read_parquet_file(). "); } #endif @@ -2581,14 +2581,14 @@ SEXP _arrow_read_parquet_file(SEXP filename_sexp){ // recordbatch.cpp:26 #if defined(ARROW_R_WITH_ARROW) int RecordBatch__num_columns(const std::shared_ptr& x); -SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(RecordBatch__num_columns(x)); END_RCPP } #else -SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_columns(). "); } #endif @@ -2596,14 +2596,14 @@ SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ // recordbatch.cpp:31 #if defined(ARROW_R_WITH_ARROW) int RecordBatch__num_rows(const std::shared_ptr& x); -SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(RecordBatch__num_rows(x)); END_RCPP } #else -SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_rows(). "); } #endif @@ -2611,14 +2611,14 @@ SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ // recordbatch.cpp:36 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__schema(const std::shared_ptr& x); -SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(RecordBatch__schema(x)); END_RCPP } #else -SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ +RcppExport SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__schema(). "); } #endif @@ -2626,14 +2626,14 @@ SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ // recordbatch.cpp:42 #if defined(ARROW_R_WITH_ARROW) arrow::ArrayVector RecordBatch__columns(const std::shared_ptr& batch); -SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ +RcppExport SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); return Rcpp::wrap(RecordBatch__columns(batch)); END_RCPP } #else -SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ +RcppExport SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__columns(). "); } #endif @@ -2641,7 +2641,7 @@ SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ // recordbatch.cpp:53 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__column(const std::shared_ptr& batch, int i); -SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -2649,7 +2649,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__column(). "); } #endif @@ -2657,14 +2657,14 @@ SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ // recordbatch.cpp:59 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__from_dataframe(Rcpp::DataFrame tbl); -SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ +RcppExport SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type tbl(tbl_sexp); return Rcpp::wrap(RecordBatch__from_dataframe(tbl)); END_RCPP } #else -SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ +RcppExport SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_dataframe(). "); } #endif @@ -2672,7 +2672,7 @@ SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ // recordbatch.cpp:77 #if defined(ARROW_R_WITH_ARROW) bool RecordBatch__Equals(const std::shared_ptr& self, const std::shared_ptr& other); -SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ +RcppExport SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type self(self_sexp); Rcpp::traits::input_parameter&>::type other(other_sexp); @@ -2680,7 +2680,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ +RcppExport SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__Equals(). "); } #endif @@ -2688,7 +2688,7 @@ SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ // recordbatch.cpp:83 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__RemoveColumn(const std::shared_ptr& batch, int i); -SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -2696,7 +2696,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__RemoveColumn(). "); } #endif @@ -2704,7 +2704,7 @@ SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ // recordbatch.cpp:91 #if defined(ARROW_R_WITH_ARROW) std::string RecordBatch__column_name(const std::shared_ptr& batch, int i); -SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -2712,7 +2712,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__column_name(). "); } #endif @@ -2720,14 +2720,14 @@ SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ // recordbatch.cpp:97 #if defined(ARROW_R_WITH_ARROW) Rcpp::CharacterVector RecordBatch__names(const std::shared_ptr& batch); -SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ +RcppExport SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); return Rcpp::wrap(RecordBatch__names(batch)); END_RCPP } #else -SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ +RcppExport SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__names(). "); } #endif @@ -2735,7 +2735,7 @@ SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ // recordbatch.cpp:108 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__Slice1(const std::shared_ptr& self, int offset); -SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type self(self_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -2743,7 +2743,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ +RcppExport SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice1(). "); } #endif @@ -2751,7 +2751,7 @@ SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ // recordbatch.cpp:114 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__Slice2(const std::shared_ptr& self, int offset, int length); -SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type self(self_sexp); Rcpp::traits::input_parameter::type offset(offset_sexp); @@ -2760,7 +2760,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ +RcppExport SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice2(). "); } #endif @@ -2768,14 +2768,14 @@ SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_se // recordbatch.cpp:120 #if defined(ARROW_R_WITH_ARROW) Rcpp::RawVector ipc___SerializeRecordBatch__Raw(const std::shared_ptr& batch); -SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch(batch_sexp); return Rcpp::wrap(ipc___SerializeRecordBatch__Raw(batch)); END_RCPP } #else -SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___SerializeRecordBatch__Raw(). "); } #endif @@ -2783,7 +2783,7 @@ SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ // recordbatch.cpp:140 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___ReadRecordBatch__InputStream__Schema(const std::shared_ptr& stream, const std::shared_ptr& schema); -SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -2791,7 +2791,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__InputStream__Schema(). "); } #endif @@ -2799,7 +2799,7 @@ SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP sc // recordbatch.cpp:189 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatch__from_arrays(SEXP schema_sxp, SEXP lst); -SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ +RcppExport SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); Rcpp::traits::input_parameter::type lst(lst_sexp); @@ -2807,7 +2807,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ +RcppExport SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_arrays(). "); } #endif @@ -2815,14 +2815,14 @@ SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ // recordbatchreader.cpp:22 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatchReader__schema(const std::shared_ptr& reader); -SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ +RcppExport SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(RecordBatchReader__schema(reader)); END_RCPP } #else -SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ +RcppExport SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__schema(). "); } #endif @@ -2830,14 +2830,14 @@ SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ // recordbatchreader.cpp:28 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr RecordBatchReader__ReadNext(const std::shared_ptr& reader); -SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ +RcppExport SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(RecordBatchReader__ReadNext(reader)); END_RCPP } #else -SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ +RcppExport SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__ReadNext(). "); } #endif @@ -2845,14 +2845,14 @@ SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ // recordbatchreader.cpp:38 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchStreamReader__Open(const std::shared_ptr& stream); -SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); return Rcpp::wrap(ipc___RecordBatchStreamReader__Open(stream)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__Open(). "); } #endif @@ -2860,14 +2860,14 @@ SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ // recordbatchreader.cpp:46 #if defined(ARROW_R_WITH_ARROW) std::vector> ipc___RecordBatchStreamReader__batches(const std::shared_ptr& reader); -SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___RecordBatchStreamReader__batches(reader)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__batches(). "); } #endif @@ -2875,14 +2875,14 @@ SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ // recordbatchreader.cpp:64 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__schema(const std::shared_ptr& reader); -SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___RecordBatchFileReader__schema(reader)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__schema(). "); } #endif @@ -2890,14 +2890,14 @@ SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ // recordbatchreader.cpp:70 #if defined(ARROW_R_WITH_ARROW) int ipc___RecordBatchFileReader__num_record_batches(const std::shared_ptr& reader); -SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___RecordBatchFileReader__num_record_batches(reader)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__num_record_batches(). "); } #endif @@ -2905,7 +2905,7 @@ SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ // recordbatchreader.cpp:76 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__ReadRecordBatch(const std::shared_ptr& reader, int i); -SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -2913,7 +2913,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__ReadRecordBatch(). "); } #endif @@ -2921,14 +2921,14 @@ SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP // recordbatchreader.cpp:86 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileReader__Open(const std::shared_ptr& file); -SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type file(file_sexp); return Rcpp::wrap(ipc___RecordBatchFileReader__Open(file)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__Open(). "); } #endif @@ -2936,14 +2936,14 @@ SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ // recordbatchreader.cpp:94 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_RecordBatchFileReader(const std::shared_ptr& reader); -SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ +RcppExport SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(Table__from_RecordBatchFileReader(reader)); END_RCPP } #else -SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ +RcppExport SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchFileReader(). "); } #endif @@ -2951,14 +2951,14 @@ SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ // recordbatchreader.cpp:109 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_RecordBatchStreamReader(const std::shared_ptr& reader); -SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ +RcppExport SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(Table__from_RecordBatchStreamReader(reader)); END_RCPP } #else -SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ +RcppExport SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchStreamReader(). "); } #endif @@ -2966,14 +2966,14 @@ SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ // recordbatchreader.cpp:126 #if defined(ARROW_R_WITH_ARROW) std::vector> ipc___RecordBatchFileReader__batches(const std::shared_ptr& reader); -SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type reader(reader_sexp); return Rcpp::wrap(ipc___RecordBatchFileReader__batches(reader)); END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__batches(). "); } #endif @@ -2981,7 +2981,7 @@ SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ // recordbatchwriter.cpp:22 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__WriteRecordBatch(const std::shared_ptr& batch_writer, const std::shared_ptr& batch); -SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); Rcpp::traits::input_parameter&>::type batch(batch_sexp); @@ -2990,7 +2990,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteRecordBatch(). "); } #endif @@ -2998,7 +2998,7 @@ SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SE // recordbatchwriter.cpp:29 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__WriteTable(const std::shared_ptr& batch_writer, const std::shared_ptr& table); -SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); Rcpp::traits::input_parameter&>::type table(table_sexp); @@ -3007,7 +3007,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteTable(). "); } #endif @@ -3015,7 +3015,7 @@ SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP tab // recordbatchwriter.cpp:36 #if defined(ARROW_R_WITH_ARROW) void ipc___RecordBatchWriter__Close(const std::shared_ptr& batch_writer); -SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type batch_writer(batch_writer_sexp); ipc___RecordBatchWriter__Close(batch_writer); @@ -3023,7 +3023,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__Close(). "); } #endif @@ -3031,7 +3031,7 @@ SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ // recordbatchwriter.cpp:42 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchFileWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); -SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -3039,7 +3039,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileWriter__Open(). "); } #endif @@ -3047,7 +3047,7 @@ SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp // recordbatchwriter.cpp:52 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr ipc___RecordBatchStreamWriter__Open(const std::shared_ptr& stream, const std::shared_ptr& schema); -SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type stream(stream_sexp); Rcpp::traits::input_parameter&>::type schema(schema_sexp); @@ -3055,7 +3055,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ +RcppExport SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamWriter__Open(). "); } #endif @@ -3063,14 +3063,14 @@ SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_se // table.cpp:27 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_dataframe(DataFrame tbl); -SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ +RcppExport SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type tbl(tbl_sexp); return Rcpp::wrap(Table__from_dataframe(tbl)); END_RCPP } #else -SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ +RcppExport SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__from_dataframe(). "); } #endif @@ -3078,14 +3078,14 @@ SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ // table.cpp:36 #if defined(ARROW_R_WITH_ARROW) int Table__num_columns(const std::shared_ptr& x); -SEXP _arrow_Table__num_columns(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__num_columns(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Table__num_columns(x)); END_RCPP } #else -SEXP _arrow_Table__num_columns(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__num_columns(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__num_columns(). "); } #endif @@ -3093,14 +3093,14 @@ SEXP _arrow_Table__num_columns(SEXP x_sexp){ // table.cpp:41 #if defined(ARROW_R_WITH_ARROW) int Table__num_rows(const std::shared_ptr& x); -SEXP _arrow_Table__num_rows(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__num_rows(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Table__num_rows(x)); END_RCPP } #else -SEXP _arrow_Table__num_rows(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__num_rows(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__num_rows(). "); } #endif @@ -3108,14 +3108,14 @@ SEXP _arrow_Table__num_rows(SEXP x_sexp){ // table.cpp:44 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__schema(const std::shared_ptr& x); -SEXP _arrow_Table__schema(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__schema(SEXP x_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type x(x_sexp); return Rcpp::wrap(Table__schema(x)); END_RCPP } #else -SEXP _arrow_Table__schema(SEXP x_sexp){ +RcppExport SEXP _arrow_Table__schema(SEXP x_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__schema(). "); } #endif @@ -3123,7 +3123,7 @@ SEXP _arrow_Table__schema(SEXP x_sexp){ // table.cpp:49 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__column(const std::shared_ptr& table, int i); -SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type table(table_sexp); Rcpp::traits::input_parameter::type i(i_sexp); @@ -3131,7 +3131,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ +RcppExport SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__column(). "); } #endif @@ -3139,14 +3139,14 @@ SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ // table.cpp:55 #if defined(ARROW_R_WITH_ARROW) std::vector> Table__columns(const std::shared_ptr& table); -SEXP _arrow_Table__columns(SEXP table_sexp){ +RcppExport SEXP _arrow_Table__columns(SEXP table_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter&>::type table(table_sexp); return Rcpp::wrap(Table__columns(table)); END_RCPP } #else -SEXP _arrow_Table__columns(SEXP table_sexp){ +RcppExport SEXP _arrow_Table__columns(SEXP table_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__columns(). "); } #endif @@ -3154,7 +3154,7 @@ SEXP _arrow_Table__columns(SEXP table_sexp){ // table.cpp:74 #if defined(ARROW_R_WITH_ARROW) std::shared_ptr Table__from_dots(SEXP lst, SEXP schema_sxp); -SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ +RcppExport SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type lst(lst_sexp); Rcpp::traits::input_parameter::type schema_sxp(schema_sxp_sexp); @@ -3162,7 +3162,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ +RcppExport SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ Rf_error("arrow C++ library not available. Cannot call Table__from_dots(). "); } #endif @@ -3170,13 +3170,13 @@ SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ // threadpool.cpp:41 #if defined(ARROW_R_WITH_ARROW) int GetCpuThreadPoolCapacity(); -SEXP _arrow_GetCpuThreadPoolCapacity(){ +RcppExport SEXP _arrow_GetCpuThreadPoolCapacity(){ BEGIN_RCPP return Rcpp::wrap(GetCpuThreadPoolCapacity()); END_RCPP } #else -SEXP _arrow_GetCpuThreadPoolCapacity(){ +RcppExport SEXP _arrow_GetCpuThreadPoolCapacity(){ Rf_error("arrow C++ library not available. Cannot call GetCpuThreadPoolCapacity(). "); } #endif @@ -3184,7 +3184,7 @@ SEXP _arrow_GetCpuThreadPoolCapacity(){ // threadpool.cpp:46 #if defined(ARROW_R_WITH_ARROW) void SetCpuThreadPoolCapacity(int threads); -SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ +RcppExport SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ BEGIN_RCPP Rcpp::traits::input_parameter::type threads(threads_sexp); SetCpuThreadPoolCapacity(threads); @@ -3192,7 +3192,7 @@ BEGIN_RCPP END_RCPP } #else -SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ +RcppExport SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ Rf_error("arrow C++ library not available. Cannot call SetCpuThreadPoolCapacity(). "); } #endif @@ -3210,218 +3210,218 @@ return Rf_ScalarLogical( static const R_CallMethodDef CallEntries[] = { { "_arrow_available", (DL_FUNC)& _arrow_available, 0 }, - { "_arrow_Array__Slice1", (DL_FUNC)& _arrow_Array__Slice1, 2}, - { "_arrow_Array__Slice2", (DL_FUNC)& _arrow_Array__Slice2, 3}, - { "_arrow_Array__IsNull", (DL_FUNC)& _arrow_Array__IsNull, 2}, - { "_arrow_Array__IsValid", (DL_FUNC)& _arrow_Array__IsValid, 2}, - { "_arrow_Array__length", (DL_FUNC)& _arrow_Array__length, 1}, - { "_arrow_Array__offset", (DL_FUNC)& _arrow_Array__offset, 1}, - { "_arrow_Array__null_count", (DL_FUNC)& _arrow_Array__null_count, 1}, - { "_arrow_Array__type", (DL_FUNC)& _arrow_Array__type, 1}, - { "_arrow_Array__ToString", (DL_FUNC)& _arrow_Array__ToString, 1}, - { "_arrow_Array__type_id", (DL_FUNC)& _arrow_Array__type_id, 1}, - { "_arrow_Array__Equals", (DL_FUNC)& _arrow_Array__Equals, 2}, - { "_arrow_Array__ApproxEquals", (DL_FUNC)& _arrow_Array__ApproxEquals, 2}, - { "_arrow_Array__data", (DL_FUNC)& _arrow_Array__data, 1}, - { "_arrow_Array__RangeEquals", (DL_FUNC)& _arrow_Array__RangeEquals, 5}, - { "_arrow_Array__Mask", (DL_FUNC)& _arrow_Array__Mask, 1}, - { "_arrow_DictionaryArray__indices", (DL_FUNC)& _arrow_DictionaryArray__indices, 1}, - { "_arrow_DictionaryArray__dictionary", (DL_FUNC)& _arrow_DictionaryArray__dictionary, 1}, - { "_arrow_Array__as_vector", (DL_FUNC)& _arrow_Array__as_vector, 1}, - { "_arrow_ChunkedArray__as_vector", (DL_FUNC)& _arrow_ChunkedArray__as_vector, 1}, - { "_arrow_RecordBatch__to_dataframe", (DL_FUNC)& _arrow_RecordBatch__to_dataframe, 2}, - { "_arrow_Table__to_dataframe", (DL_FUNC)& _arrow_Table__to_dataframe, 2}, - { "_arrow_Array__infer_type", (DL_FUNC)& _arrow_Array__infer_type, 1}, - { "_arrow_Array__from_vector", (DL_FUNC)& _arrow_Array__from_vector, 2}, - { "_arrow_ChunkedArray__from_list", (DL_FUNC)& _arrow_ChunkedArray__from_list, 2}, - { "_arrow_ArrayData__get_type", (DL_FUNC)& _arrow_ArrayData__get_type, 1}, - { "_arrow_ArrayData__get_length", (DL_FUNC)& _arrow_ArrayData__get_length, 1}, - { "_arrow_ArrayData__get_null_count", (DL_FUNC)& _arrow_ArrayData__get_null_count, 1}, - { "_arrow_ArrayData__get_offset", (DL_FUNC)& _arrow_ArrayData__get_offset, 1}, - { "_arrow_ArrayData__buffers", (DL_FUNC)& _arrow_ArrayData__buffers, 1}, - { "_arrow_Buffer__is_mutable", (DL_FUNC)& _arrow_Buffer__is_mutable, 1}, - { "_arrow_Buffer__ZeroPadding", (DL_FUNC)& _arrow_Buffer__ZeroPadding, 1}, - { "_arrow_Buffer__capacity", (DL_FUNC)& _arrow_Buffer__capacity, 1}, - { "_arrow_Buffer__size", (DL_FUNC)& _arrow_Buffer__size, 1}, - { "_arrow_r___RBuffer__initialize", (DL_FUNC)& _arrow_r___RBuffer__initialize, 1}, - { "_arrow_ChunkedArray__length", (DL_FUNC)& _arrow_ChunkedArray__length, 1}, - { "_arrow_ChunkedArray__null_count", (DL_FUNC)& _arrow_ChunkedArray__null_count, 1}, - { "_arrow_ChunkedArray__num_chunks", (DL_FUNC)& _arrow_ChunkedArray__num_chunks, 1}, - { "_arrow_ChunkedArray__chunk", (DL_FUNC)& _arrow_ChunkedArray__chunk, 2}, - { "_arrow_ChunkedArray__chunks", (DL_FUNC)& _arrow_ChunkedArray__chunks, 1}, - { "_arrow_ChunkedArray__type", (DL_FUNC)& _arrow_ChunkedArray__type, 1}, - { "_arrow_ChunkArray__Slice1", (DL_FUNC)& _arrow_ChunkArray__Slice1, 2}, - { "_arrow_ChunkArray__Slice2", (DL_FUNC)& _arrow_ChunkArray__Slice2, 3}, - { "_arrow_Column__length", (DL_FUNC)& _arrow_Column__length, 1}, - { "_arrow_Column__null_count", (DL_FUNC)& _arrow_Column__null_count, 1}, - { "_arrow_Column__type", (DL_FUNC)& _arrow_Column__type, 1}, - { "_arrow_Column__data", (DL_FUNC)& _arrow_Column__data, 1}, - { "_arrow_util___Codec__Create", (DL_FUNC)& _arrow_util___Codec__Create, 1}, - { "_arrow_io___CompressedOutputStream__Make", (DL_FUNC)& _arrow_io___CompressedOutputStream__Make, 2}, - { "_arrow_io___CompressedInputStream__Make", (DL_FUNC)& _arrow_io___CompressedInputStream__Make, 2}, - { "_arrow_compute___CastOptions__initialize", (DL_FUNC)& _arrow_compute___CastOptions__initialize, 3}, - { "_arrow_Array__cast", (DL_FUNC)& _arrow_Array__cast, 3}, - { "_arrow_ChunkedArray__cast", (DL_FUNC)& _arrow_ChunkedArray__cast, 3}, - { "_arrow_RecordBatch__cast", (DL_FUNC)& _arrow_RecordBatch__cast, 3}, - { "_arrow_Table__cast", (DL_FUNC)& _arrow_Table__cast, 3}, - { "_arrow_csv___ReadOptions__initialize", (DL_FUNC)& _arrow_csv___ReadOptions__initialize, 1}, - { "_arrow_csv___ParseOptions__initialize", (DL_FUNC)& _arrow_csv___ParseOptions__initialize, 1}, - { "_arrow_csv___ConvertOptions__initialize", (DL_FUNC)& _arrow_csv___ConvertOptions__initialize, 1}, - { "_arrow_csv___TableReader__Make", (DL_FUNC)& _arrow_csv___TableReader__Make, 4}, - { "_arrow_csv___TableReader__Read", (DL_FUNC)& _arrow_csv___TableReader__Read, 1}, - { "_arrow_shared_ptr_is_null", (DL_FUNC)& _arrow_shared_ptr_is_null, 1}, - { "_arrow_unique_ptr_is_null", (DL_FUNC)& _arrow_unique_ptr_is_null, 1}, - { "_arrow_Int8__initialize", (DL_FUNC)& _arrow_Int8__initialize, 0}, - { "_arrow_Int16__initialize", (DL_FUNC)& _arrow_Int16__initialize, 0}, - { "_arrow_Int32__initialize", (DL_FUNC)& _arrow_Int32__initialize, 0}, - { "_arrow_Int64__initialize", (DL_FUNC)& _arrow_Int64__initialize, 0}, - { "_arrow_UInt8__initialize", (DL_FUNC)& _arrow_UInt8__initialize, 0}, - { "_arrow_UInt16__initialize", (DL_FUNC)& _arrow_UInt16__initialize, 0}, - { "_arrow_UInt32__initialize", (DL_FUNC)& _arrow_UInt32__initialize, 0}, - { "_arrow_UInt64__initialize", (DL_FUNC)& _arrow_UInt64__initialize, 0}, - { "_arrow_Float16__initialize", (DL_FUNC)& _arrow_Float16__initialize, 0}, - { "_arrow_Float32__initialize", (DL_FUNC)& _arrow_Float32__initialize, 0}, - { "_arrow_Float64__initialize", (DL_FUNC)& _arrow_Float64__initialize, 0}, - { "_arrow_Boolean__initialize", (DL_FUNC)& _arrow_Boolean__initialize, 0}, - { "_arrow_Utf8__initialize", (DL_FUNC)& _arrow_Utf8__initialize, 0}, - { "_arrow_Date32__initialize", (DL_FUNC)& _arrow_Date32__initialize, 0}, - { "_arrow_Date64__initialize", (DL_FUNC)& _arrow_Date64__initialize, 0}, - { "_arrow_Null__initialize", (DL_FUNC)& _arrow_Null__initialize, 0}, - { "_arrow_Decimal128Type__initialize", (DL_FUNC)& _arrow_Decimal128Type__initialize, 2}, - { "_arrow_FixedSizeBinary__initialize", (DL_FUNC)& _arrow_FixedSizeBinary__initialize, 1}, - { "_arrow_Timestamp__initialize1", (DL_FUNC)& _arrow_Timestamp__initialize1, 1}, - { "_arrow_Timestamp__initialize2", (DL_FUNC)& _arrow_Timestamp__initialize2, 2}, - { "_arrow_Time32__initialize", (DL_FUNC)& _arrow_Time32__initialize, 1}, - { "_arrow_Time64__initialize", (DL_FUNC)& _arrow_Time64__initialize, 1}, - { "_arrow_list__", (DL_FUNC)& _arrow_list__, 1}, - { "_arrow_struct_", (DL_FUNC)& _arrow_struct_, 1}, - { "_arrow_DataType__ToString", (DL_FUNC)& _arrow_DataType__ToString, 1}, - { "_arrow_DataType__name", (DL_FUNC)& _arrow_DataType__name, 1}, - { "_arrow_DataType__Equals", (DL_FUNC)& _arrow_DataType__Equals, 2}, - { "_arrow_DataType__num_children", (DL_FUNC)& _arrow_DataType__num_children, 1}, - { "_arrow_DataType__children_pointer", (DL_FUNC)& _arrow_DataType__children_pointer, 1}, - { "_arrow_DataType__id", (DL_FUNC)& _arrow_DataType__id, 1}, - { "_arrow_schema_", (DL_FUNC)& _arrow_schema_, 1}, - { "_arrow_Schema__ToString", (DL_FUNC)& _arrow_Schema__ToString, 1}, - { "_arrow_Schema__num_fields", (DL_FUNC)& _arrow_Schema__num_fields, 1}, - { "_arrow_Schema__field", (DL_FUNC)& _arrow_Schema__field, 2}, - { "_arrow_Schema__names", (DL_FUNC)& _arrow_Schema__names, 1}, - { "_arrow_ListType__ToString", (DL_FUNC)& _arrow_ListType__ToString, 1}, - { "_arrow_FixedWidthType__bit_width", (DL_FUNC)& _arrow_FixedWidthType__bit_width, 1}, - { "_arrow_DateType__unit", (DL_FUNC)& _arrow_DateType__unit, 1}, - { "_arrow_TimeType__unit", (DL_FUNC)& _arrow_TimeType__unit, 1}, - { "_arrow_DecimalType__precision", (DL_FUNC)& _arrow_DecimalType__precision, 1}, - { "_arrow_DecimalType__scale", (DL_FUNC)& _arrow_DecimalType__scale, 1}, - { "_arrow_TimestampType__timezone", (DL_FUNC)& _arrow_TimestampType__timezone, 1}, - { "_arrow_TimestampType__unit", (DL_FUNC)& _arrow_TimestampType__unit, 1}, - { "_arrow_DictionaryType__initialize", (DL_FUNC)& _arrow_DictionaryType__initialize, 3}, - { "_arrow_DictionaryType__index_type", (DL_FUNC)& _arrow_DictionaryType__index_type, 1}, - { "_arrow_DictionaryType__value_type", (DL_FUNC)& _arrow_DictionaryType__value_type, 1}, - { "_arrow_DictionaryType__name", (DL_FUNC)& _arrow_DictionaryType__name, 1}, - { "_arrow_DictionaryType__ordered", (DL_FUNC)& _arrow_DictionaryType__ordered, 1}, - { "_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetDescription, 2}, - { "_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC)& _arrow_ipc___feather___TableWriter__SetNumRows, 2}, - { "_arrow_ipc___feather___TableWriter__Append", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Append, 3}, - { "_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Finalize, 1}, - { "_arrow_ipc___feather___TableWriter__Open", (DL_FUNC)& _arrow_ipc___feather___TableWriter__Open, 1}, - { "_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC)& _arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2}, - { "_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetDescription, 1}, - { "_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC)& _arrow_ipc___feather___TableReader__HasDescription, 1}, - { "_arrow_ipc___feather___TableReader__version", (DL_FUNC)& _arrow_ipc___feather___TableReader__version, 1}, - { "_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_rows, 1}, - { "_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC)& _arrow_ipc___feather___TableReader__num_columns, 1}, - { "_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumnName, 2}, - { "_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC)& _arrow_ipc___feather___TableReader__GetColumn, 2}, - { "_arrow_ipc___feather___TableReader__Read", (DL_FUNC)& _arrow_ipc___feather___TableReader__Read, 2}, - { "_arrow_ipc___feather___TableReader__Open", (DL_FUNC)& _arrow_ipc___feather___TableReader__Open, 1}, - { "_arrow_Field__initialize", (DL_FUNC)& _arrow_Field__initialize, 3}, - { "_arrow_Field__ToString", (DL_FUNC)& _arrow_Field__ToString, 1}, - { "_arrow_Field__name", (DL_FUNC)& _arrow_Field__name, 1}, - { "_arrow_Field__Equals", (DL_FUNC)& _arrow_Field__Equals, 2}, - { "_arrow_Field__nullable", (DL_FUNC)& _arrow_Field__nullable, 1}, - { "_arrow_Field__type", (DL_FUNC)& _arrow_Field__type, 1}, - { "_arrow_io___Readable__Read", (DL_FUNC)& _arrow_io___Readable__Read, 2}, - { "_arrow_io___InputStream__Close", (DL_FUNC)& _arrow_io___InputStream__Close, 1}, - { "_arrow_io___OutputStream__Close", (DL_FUNC)& _arrow_io___OutputStream__Close, 1}, - { "_arrow_io___RandomAccessFile__GetSize", (DL_FUNC)& _arrow_io___RandomAccessFile__GetSize, 1}, - { "_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC)& _arrow_io___RandomAccessFile__supports_zero_copy, 1}, - { "_arrow_io___RandomAccessFile__Seek", (DL_FUNC)& _arrow_io___RandomAccessFile__Seek, 2}, - { "_arrow_io___RandomAccessFile__Tell", (DL_FUNC)& _arrow_io___RandomAccessFile__Tell, 1}, - { "_arrow_io___MemoryMappedFile__Create", (DL_FUNC)& _arrow_io___MemoryMappedFile__Create, 2}, - { "_arrow_io___MemoryMappedFile__Open", (DL_FUNC)& _arrow_io___MemoryMappedFile__Open, 2}, - { "_arrow_io___MemoryMappedFile__Resize", (DL_FUNC)& _arrow_io___MemoryMappedFile__Resize, 2}, - { "_arrow_io___ReadableFile__Open", (DL_FUNC)& _arrow_io___ReadableFile__Open, 1}, - { "_arrow_io___BufferReader__initialize", (DL_FUNC)& _arrow_io___BufferReader__initialize, 1}, - { "_arrow_io___Writable__write", (DL_FUNC)& _arrow_io___Writable__write, 2}, - { "_arrow_io___OutputStream__Tell", (DL_FUNC)& _arrow_io___OutputStream__Tell, 1}, - { "_arrow_io___FileOutputStream__Open", (DL_FUNC)& _arrow_io___FileOutputStream__Open, 1}, - { "_arrow_io___BufferOutputStream__Create", (DL_FUNC)& _arrow_io___BufferOutputStream__Create, 1}, - { "_arrow_io___BufferOutputStream__capacity", (DL_FUNC)& _arrow_io___BufferOutputStream__capacity, 1}, - { "_arrow_io___BufferOutputStream__Finish", (DL_FUNC)& _arrow_io___BufferOutputStream__Finish, 1}, - { "_arrow_io___BufferOutputStream__Tell", (DL_FUNC)& _arrow_io___BufferOutputStream__Tell, 1}, - { "_arrow_io___BufferOutputStream__Write", (DL_FUNC)& _arrow_io___BufferOutputStream__Write, 2}, - { "_arrow_io___MockOutputStream__initialize", (DL_FUNC)& _arrow_io___MockOutputStream__initialize, 0}, - { "_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC)& _arrow_io___MockOutputStream__GetExtentBytesWritten, 1}, - { "_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC)& _arrow_io___FixedSizeBufferWriter__initialize, 1}, - { "_arrow_MemoryPool__default", (DL_FUNC)& _arrow_MemoryPool__default, 0}, - { "_arrow_MemoryPool__bytes_allocated", (DL_FUNC)& _arrow_MemoryPool__bytes_allocated, 1}, - { "_arrow_MemoryPool__max_memory", (DL_FUNC)& _arrow_MemoryPool__max_memory, 1}, - { "_arrow_ipc___Message__body_length", (DL_FUNC)& _arrow_ipc___Message__body_length, 1}, - { "_arrow_ipc___Message__metadata", (DL_FUNC)& _arrow_ipc___Message__metadata, 1}, - { "_arrow_ipc___Message__body", (DL_FUNC)& _arrow_ipc___Message__body, 1}, - { "_arrow_ipc___Message__Verify", (DL_FUNC)& _arrow_ipc___Message__Verify, 1}, - { "_arrow_ipc___Message__type", (DL_FUNC)& _arrow_ipc___Message__type, 1}, - { "_arrow_ipc___Message__Equals", (DL_FUNC)& _arrow_ipc___Message__Equals, 2}, - { "_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__Message__Schema, 2}, - { "_arrow_ipc___ReadSchema_InputStream", (DL_FUNC)& _arrow_ipc___ReadSchema_InputStream, 1}, - { "_arrow_ipc___MessageReader__Open", (DL_FUNC)& _arrow_ipc___MessageReader__Open, 1}, - { "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC)& _arrow_ipc___MessageReader__ReadNextMessage, 1}, - { "_arrow_ipc___ReadMessage", (DL_FUNC)& _arrow_ipc___ReadMessage, 1}, - { "_arrow_read_parquet_file", (DL_FUNC)& _arrow_read_parquet_file, 1}, - { "_arrow_RecordBatch__num_columns", (DL_FUNC)& _arrow_RecordBatch__num_columns, 1}, - { "_arrow_RecordBatch__num_rows", (DL_FUNC)& _arrow_RecordBatch__num_rows, 1}, - { "_arrow_RecordBatch__schema", (DL_FUNC)& _arrow_RecordBatch__schema, 1}, - { "_arrow_RecordBatch__columns", (DL_FUNC)& _arrow_RecordBatch__columns, 1}, - { "_arrow_RecordBatch__column", (DL_FUNC)& _arrow_RecordBatch__column, 2}, - { "_arrow_RecordBatch__from_dataframe", (DL_FUNC)& _arrow_RecordBatch__from_dataframe, 1}, - { "_arrow_RecordBatch__Equals", (DL_FUNC)& _arrow_RecordBatch__Equals, 2}, - { "_arrow_RecordBatch__RemoveColumn", (DL_FUNC)& _arrow_RecordBatch__RemoveColumn, 2}, - { "_arrow_RecordBatch__column_name", (DL_FUNC)& _arrow_RecordBatch__column_name, 2}, - { "_arrow_RecordBatch__names", (DL_FUNC)& _arrow_RecordBatch__names, 1}, - { "_arrow_RecordBatch__Slice1", (DL_FUNC)& _arrow_RecordBatch__Slice1, 2}, - { "_arrow_RecordBatch__Slice2", (DL_FUNC)& _arrow_RecordBatch__Slice2, 3}, - { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC)& _arrow_ipc___SerializeRecordBatch__Raw, 1}, - { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC)& _arrow_ipc___ReadRecordBatch__InputStream__Schema, 2}, - { "_arrow_RecordBatch__from_arrays", (DL_FUNC)& _arrow_RecordBatch__from_arrays, 2}, - { "_arrow_RecordBatchReader__schema", (DL_FUNC)& _arrow_RecordBatchReader__schema, 1}, - { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC)& _arrow_RecordBatchReader__ReadNext, 1}, - { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__Open, 1}, - { "_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchStreamReader__batches, 1}, - { "_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__schema, 1}, - { "_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__num_record_batches, 1}, - { "_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2}, - { "_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__Open, 1}, - { "_arrow_Table__from_RecordBatchFileReader", (DL_FUNC)& _arrow_Table__from_RecordBatchFileReader, 1}, - { "_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC)& _arrow_Table__from_RecordBatchStreamReader, 1}, - { "_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC)& _arrow_ipc___RecordBatchFileReader__batches, 1}, - { "_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2}, - { "_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__WriteTable, 2}, - { "_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC)& _arrow_ipc___RecordBatchWriter__Close, 1}, - { "_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchFileWriter__Open, 2}, - { "_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC)& _arrow_ipc___RecordBatchStreamWriter__Open, 2}, - { "_arrow_Table__from_dataframe", (DL_FUNC)& _arrow_Table__from_dataframe, 1}, - { "_arrow_Table__num_columns", (DL_FUNC)& _arrow_Table__num_columns, 1}, - { "_arrow_Table__num_rows", (DL_FUNC)& _arrow_Table__num_rows, 1}, - { "_arrow_Table__schema", (DL_FUNC)& _arrow_Table__schema, 1}, - { "_arrow_Table__column", (DL_FUNC)& _arrow_Table__column, 2}, - { "_arrow_Table__columns", (DL_FUNC)& _arrow_Table__columns, 1}, - { "_arrow_Table__from_dots", (DL_FUNC)& _arrow_Table__from_dots, 2}, - { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_GetCpuThreadPoolCapacity, 0}, - { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC)& _arrow_SetCpuThreadPoolCapacity, 1}, + { "_arrow_Array__Slice1", (DL_FUNC) &_arrow_Array__Slice1, 2}, + { "_arrow_Array__Slice2", (DL_FUNC) &_arrow_Array__Slice2, 3}, + { "_arrow_Array__IsNull", (DL_FUNC) &_arrow_Array__IsNull, 2}, + { "_arrow_Array__IsValid", (DL_FUNC) &_arrow_Array__IsValid, 2}, + { "_arrow_Array__length", (DL_FUNC) &_arrow_Array__length, 1}, + { "_arrow_Array__offset", (DL_FUNC) &_arrow_Array__offset, 1}, + { "_arrow_Array__null_count", (DL_FUNC) &_arrow_Array__null_count, 1}, + { "_arrow_Array__type", (DL_FUNC) &_arrow_Array__type, 1}, + { "_arrow_Array__ToString", (DL_FUNC) &_arrow_Array__ToString, 1}, + { "_arrow_Array__type_id", (DL_FUNC) &_arrow_Array__type_id, 1}, + { "_arrow_Array__Equals", (DL_FUNC) &_arrow_Array__Equals, 2}, + { "_arrow_Array__ApproxEquals", (DL_FUNC) &_arrow_Array__ApproxEquals, 2}, + { "_arrow_Array__data", (DL_FUNC) &_arrow_Array__data, 1}, + { "_arrow_Array__RangeEquals", (DL_FUNC) &_arrow_Array__RangeEquals, 5}, + { "_arrow_Array__Mask", (DL_FUNC) &_arrow_Array__Mask, 1}, + { "_arrow_DictionaryArray__indices", (DL_FUNC) &_arrow_DictionaryArray__indices, 1}, + { "_arrow_DictionaryArray__dictionary", (DL_FUNC) &_arrow_DictionaryArray__dictionary, 1}, + { "_arrow_Array__as_vector", (DL_FUNC) &_arrow_Array__as_vector, 1}, + { "_arrow_ChunkedArray__as_vector", (DL_FUNC) &_arrow_ChunkedArray__as_vector, 1}, + { "_arrow_RecordBatch__to_dataframe", (DL_FUNC) &_arrow_RecordBatch__to_dataframe, 2}, + { "_arrow_Table__to_dataframe", (DL_FUNC) &_arrow_Table__to_dataframe, 2}, + { "_arrow_Array__infer_type", (DL_FUNC) &_arrow_Array__infer_type, 1}, + { "_arrow_Array__from_vector", (DL_FUNC) &_arrow_Array__from_vector, 2}, + { "_arrow_ChunkedArray__from_list", (DL_FUNC) &_arrow_ChunkedArray__from_list, 2}, + { "_arrow_ArrayData__get_type", (DL_FUNC) &_arrow_ArrayData__get_type, 1}, + { "_arrow_ArrayData__get_length", (DL_FUNC) &_arrow_ArrayData__get_length, 1}, + { "_arrow_ArrayData__get_null_count", (DL_FUNC) &_arrow_ArrayData__get_null_count, 1}, + { "_arrow_ArrayData__get_offset", (DL_FUNC) &_arrow_ArrayData__get_offset, 1}, + { "_arrow_ArrayData__buffers", (DL_FUNC) &_arrow_ArrayData__buffers, 1}, + { "_arrow_Buffer__is_mutable", (DL_FUNC) &_arrow_Buffer__is_mutable, 1}, + { "_arrow_Buffer__ZeroPadding", (DL_FUNC) &_arrow_Buffer__ZeroPadding, 1}, + { "_arrow_Buffer__capacity", (DL_FUNC) &_arrow_Buffer__capacity, 1}, + { "_arrow_Buffer__size", (DL_FUNC) &_arrow_Buffer__size, 1}, + { "_arrow_r___RBuffer__initialize", (DL_FUNC) &_arrow_r___RBuffer__initialize, 1}, + { "_arrow_ChunkedArray__length", (DL_FUNC) &_arrow_ChunkedArray__length, 1}, + { "_arrow_ChunkedArray__null_count", (DL_FUNC) &_arrow_ChunkedArray__null_count, 1}, + { "_arrow_ChunkedArray__num_chunks", (DL_FUNC) &_arrow_ChunkedArray__num_chunks, 1}, + { "_arrow_ChunkedArray__chunk", (DL_FUNC) &_arrow_ChunkedArray__chunk, 2}, + { "_arrow_ChunkedArray__chunks", (DL_FUNC) &_arrow_ChunkedArray__chunks, 1}, + { "_arrow_ChunkedArray__type", (DL_FUNC) &_arrow_ChunkedArray__type, 1}, + { "_arrow_ChunkArray__Slice1", (DL_FUNC) &_arrow_ChunkArray__Slice1, 2}, + { "_arrow_ChunkArray__Slice2", (DL_FUNC) &_arrow_ChunkArray__Slice2, 3}, + { "_arrow_Column__length", (DL_FUNC) &_arrow_Column__length, 1}, + { "_arrow_Column__null_count", (DL_FUNC) &_arrow_Column__null_count, 1}, + { "_arrow_Column__type", (DL_FUNC) &_arrow_Column__type, 1}, + { "_arrow_Column__data", (DL_FUNC) &_arrow_Column__data, 1}, + { "_arrow_util___Codec__Create", (DL_FUNC) &_arrow_util___Codec__Create, 1}, + { "_arrow_io___CompressedOutputStream__Make", (DL_FUNC) &_arrow_io___CompressedOutputStream__Make, 2}, + { "_arrow_io___CompressedInputStream__Make", (DL_FUNC) &_arrow_io___CompressedInputStream__Make, 2}, + { "_arrow_compute___CastOptions__initialize", (DL_FUNC) &_arrow_compute___CastOptions__initialize, 3}, + { "_arrow_Array__cast", (DL_FUNC) &_arrow_Array__cast, 3}, + { "_arrow_ChunkedArray__cast", (DL_FUNC) &_arrow_ChunkedArray__cast, 3}, + { "_arrow_RecordBatch__cast", (DL_FUNC) &_arrow_RecordBatch__cast, 3}, + { "_arrow_Table__cast", (DL_FUNC) &_arrow_Table__cast, 3}, + { "_arrow_csv___ReadOptions__initialize", (DL_FUNC) &_arrow_csv___ReadOptions__initialize, 1}, + { "_arrow_csv___ParseOptions__initialize", (DL_FUNC) &_arrow_csv___ParseOptions__initialize, 1}, + { "_arrow_csv___ConvertOptions__initialize", (DL_FUNC) &_arrow_csv___ConvertOptions__initialize, 1}, + { "_arrow_csv___TableReader__Make", (DL_FUNC) &_arrow_csv___TableReader__Make, 4}, + { "_arrow_csv___TableReader__Read", (DL_FUNC) &_arrow_csv___TableReader__Read, 1}, + { "_arrow_shared_ptr_is_null", (DL_FUNC) &_arrow_shared_ptr_is_null, 1}, + { "_arrow_unique_ptr_is_null", (DL_FUNC) &_arrow_unique_ptr_is_null, 1}, + { "_arrow_Int8__initialize", (DL_FUNC) &_arrow_Int8__initialize, 0}, + { "_arrow_Int16__initialize", (DL_FUNC) &_arrow_Int16__initialize, 0}, + { "_arrow_Int32__initialize", (DL_FUNC) &_arrow_Int32__initialize, 0}, + { "_arrow_Int64__initialize", (DL_FUNC) &_arrow_Int64__initialize, 0}, + { "_arrow_UInt8__initialize", (DL_FUNC) &_arrow_UInt8__initialize, 0}, + { "_arrow_UInt16__initialize", (DL_FUNC) &_arrow_UInt16__initialize, 0}, + { "_arrow_UInt32__initialize", (DL_FUNC) &_arrow_UInt32__initialize, 0}, + { "_arrow_UInt64__initialize", (DL_FUNC) &_arrow_UInt64__initialize, 0}, + { "_arrow_Float16__initialize", (DL_FUNC) &_arrow_Float16__initialize, 0}, + { "_arrow_Float32__initialize", (DL_FUNC) &_arrow_Float32__initialize, 0}, + { "_arrow_Float64__initialize", (DL_FUNC) &_arrow_Float64__initialize, 0}, + { "_arrow_Boolean__initialize", (DL_FUNC) &_arrow_Boolean__initialize, 0}, + { "_arrow_Utf8__initialize", (DL_FUNC) &_arrow_Utf8__initialize, 0}, + { "_arrow_Date32__initialize", (DL_FUNC) &_arrow_Date32__initialize, 0}, + { "_arrow_Date64__initialize", (DL_FUNC) &_arrow_Date64__initialize, 0}, + { "_arrow_Null__initialize", (DL_FUNC) &_arrow_Null__initialize, 0}, + { "_arrow_Decimal128Type__initialize", (DL_FUNC) &_arrow_Decimal128Type__initialize, 2}, + { "_arrow_FixedSizeBinary__initialize", (DL_FUNC) &_arrow_FixedSizeBinary__initialize, 1}, + { "_arrow_Timestamp__initialize1", (DL_FUNC) &_arrow_Timestamp__initialize1, 1}, + { "_arrow_Timestamp__initialize2", (DL_FUNC) &_arrow_Timestamp__initialize2, 2}, + { "_arrow_Time32__initialize", (DL_FUNC) &_arrow_Time32__initialize, 1}, + { "_arrow_Time64__initialize", (DL_FUNC) &_arrow_Time64__initialize, 1}, + { "_arrow_list__", (DL_FUNC) &_arrow_list__, 1}, + { "_arrow_struct_", (DL_FUNC) &_arrow_struct_, 1}, + { "_arrow_DataType__ToString", (DL_FUNC) &_arrow_DataType__ToString, 1}, + { "_arrow_DataType__name", (DL_FUNC) &_arrow_DataType__name, 1}, + { "_arrow_DataType__Equals", (DL_FUNC) &_arrow_DataType__Equals, 2}, + { "_arrow_DataType__num_children", (DL_FUNC) &_arrow_DataType__num_children, 1}, + { "_arrow_DataType__children_pointer", (DL_FUNC) &_arrow_DataType__children_pointer, 1}, + { "_arrow_DataType__id", (DL_FUNC) &_arrow_DataType__id, 1}, + { "_arrow_schema_", (DL_FUNC) &_arrow_schema_, 1}, + { "_arrow_Schema__ToString", (DL_FUNC) &_arrow_Schema__ToString, 1}, + { "_arrow_Schema__num_fields", (DL_FUNC) &_arrow_Schema__num_fields, 1}, + { "_arrow_Schema__field", (DL_FUNC) &_arrow_Schema__field, 2}, + { "_arrow_Schema__names", (DL_FUNC) &_arrow_Schema__names, 1}, + { "_arrow_ListType__ToString", (DL_FUNC) &_arrow_ListType__ToString, 1}, + { "_arrow_FixedWidthType__bit_width", (DL_FUNC) &_arrow_FixedWidthType__bit_width, 1}, + { "_arrow_DateType__unit", (DL_FUNC) &_arrow_DateType__unit, 1}, + { "_arrow_TimeType__unit", (DL_FUNC) &_arrow_TimeType__unit, 1}, + { "_arrow_DecimalType__precision", (DL_FUNC) &_arrow_DecimalType__precision, 1}, + { "_arrow_DecimalType__scale", (DL_FUNC) &_arrow_DecimalType__scale, 1}, + { "_arrow_TimestampType__timezone", (DL_FUNC) &_arrow_TimestampType__timezone, 1}, + { "_arrow_TimestampType__unit", (DL_FUNC) &_arrow_TimestampType__unit, 1}, + { "_arrow_DictionaryType__initialize", (DL_FUNC) &_arrow_DictionaryType__initialize, 3}, + { "_arrow_DictionaryType__index_type", (DL_FUNC) &_arrow_DictionaryType__index_type, 1}, + { "_arrow_DictionaryType__value_type", (DL_FUNC) &_arrow_DictionaryType__value_type, 1}, + { "_arrow_DictionaryType__name", (DL_FUNC) &_arrow_DictionaryType__name, 1}, + { "_arrow_DictionaryType__ordered", (DL_FUNC) &_arrow_DictionaryType__ordered, 1}, + { "_arrow_ipc___feather___TableWriter__SetDescription", (DL_FUNC) &_arrow_ipc___feather___TableWriter__SetDescription, 2}, + { "_arrow_ipc___feather___TableWriter__SetNumRows", (DL_FUNC) &_arrow_ipc___feather___TableWriter__SetNumRows, 2}, + { "_arrow_ipc___feather___TableWriter__Append", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Append, 3}, + { "_arrow_ipc___feather___TableWriter__Finalize", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Finalize, 1}, + { "_arrow_ipc___feather___TableWriter__Open", (DL_FUNC) &_arrow_ipc___feather___TableWriter__Open, 1}, + { "_arrow_ipc___TableWriter__RecordBatch__WriteFeather", (DL_FUNC) &_arrow_ipc___TableWriter__RecordBatch__WriteFeather, 2}, + { "_arrow_ipc___feather___TableReader__GetDescription", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetDescription, 1}, + { "_arrow_ipc___feather___TableReader__HasDescription", (DL_FUNC) &_arrow_ipc___feather___TableReader__HasDescription, 1}, + { "_arrow_ipc___feather___TableReader__version", (DL_FUNC) &_arrow_ipc___feather___TableReader__version, 1}, + { "_arrow_ipc___feather___TableReader__num_rows", (DL_FUNC) &_arrow_ipc___feather___TableReader__num_rows, 1}, + { "_arrow_ipc___feather___TableReader__num_columns", (DL_FUNC) &_arrow_ipc___feather___TableReader__num_columns, 1}, + { "_arrow_ipc___feather___TableReader__GetColumnName", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetColumnName, 2}, + { "_arrow_ipc___feather___TableReader__GetColumn", (DL_FUNC) &_arrow_ipc___feather___TableReader__GetColumn, 2}, + { "_arrow_ipc___feather___TableReader__Read", (DL_FUNC) &_arrow_ipc___feather___TableReader__Read, 2}, + { "_arrow_ipc___feather___TableReader__Open", (DL_FUNC) &_arrow_ipc___feather___TableReader__Open, 1}, + { "_arrow_Field__initialize", (DL_FUNC) &_arrow_Field__initialize, 3}, + { "_arrow_Field__ToString", (DL_FUNC) &_arrow_Field__ToString, 1}, + { "_arrow_Field__name", (DL_FUNC) &_arrow_Field__name, 1}, + { "_arrow_Field__Equals", (DL_FUNC) &_arrow_Field__Equals, 2}, + { "_arrow_Field__nullable", (DL_FUNC) &_arrow_Field__nullable, 1}, + { "_arrow_Field__type", (DL_FUNC) &_arrow_Field__type, 1}, + { "_arrow_io___Readable__Read", (DL_FUNC) &_arrow_io___Readable__Read, 2}, + { "_arrow_io___InputStream__Close", (DL_FUNC) &_arrow_io___InputStream__Close, 1}, + { "_arrow_io___OutputStream__Close", (DL_FUNC) &_arrow_io___OutputStream__Close, 1}, + { "_arrow_io___RandomAccessFile__GetSize", (DL_FUNC) &_arrow_io___RandomAccessFile__GetSize, 1}, + { "_arrow_io___RandomAccessFile__supports_zero_copy", (DL_FUNC) &_arrow_io___RandomAccessFile__supports_zero_copy, 1}, + { "_arrow_io___RandomAccessFile__Seek", (DL_FUNC) &_arrow_io___RandomAccessFile__Seek, 2}, + { "_arrow_io___RandomAccessFile__Tell", (DL_FUNC) &_arrow_io___RandomAccessFile__Tell, 1}, + { "_arrow_io___MemoryMappedFile__Create", (DL_FUNC) &_arrow_io___MemoryMappedFile__Create, 2}, + { "_arrow_io___MemoryMappedFile__Open", (DL_FUNC) &_arrow_io___MemoryMappedFile__Open, 2}, + { "_arrow_io___MemoryMappedFile__Resize", (DL_FUNC) &_arrow_io___MemoryMappedFile__Resize, 2}, + { "_arrow_io___ReadableFile__Open", (DL_FUNC) &_arrow_io___ReadableFile__Open, 1}, + { "_arrow_io___BufferReader__initialize", (DL_FUNC) &_arrow_io___BufferReader__initialize, 1}, + { "_arrow_io___Writable__write", (DL_FUNC) &_arrow_io___Writable__write, 2}, + { "_arrow_io___OutputStream__Tell", (DL_FUNC) &_arrow_io___OutputStream__Tell, 1}, + { "_arrow_io___FileOutputStream__Open", (DL_FUNC) &_arrow_io___FileOutputStream__Open, 1}, + { "_arrow_io___BufferOutputStream__Create", (DL_FUNC) &_arrow_io___BufferOutputStream__Create, 1}, + { "_arrow_io___BufferOutputStream__capacity", (DL_FUNC) &_arrow_io___BufferOutputStream__capacity, 1}, + { "_arrow_io___BufferOutputStream__Finish", (DL_FUNC) &_arrow_io___BufferOutputStream__Finish, 1}, + { "_arrow_io___BufferOutputStream__Tell", (DL_FUNC) &_arrow_io___BufferOutputStream__Tell, 1}, + { "_arrow_io___BufferOutputStream__Write", (DL_FUNC) &_arrow_io___BufferOutputStream__Write, 2}, + { "_arrow_io___MockOutputStream__initialize", (DL_FUNC) &_arrow_io___MockOutputStream__initialize, 0}, + { "_arrow_io___MockOutputStream__GetExtentBytesWritten", (DL_FUNC) &_arrow_io___MockOutputStream__GetExtentBytesWritten, 1}, + { "_arrow_io___FixedSizeBufferWriter__initialize", (DL_FUNC) &_arrow_io___FixedSizeBufferWriter__initialize, 1}, + { "_arrow_MemoryPool__default", (DL_FUNC) &_arrow_MemoryPool__default, 0}, + { "_arrow_MemoryPool__bytes_allocated", (DL_FUNC) &_arrow_MemoryPool__bytes_allocated, 1}, + { "_arrow_MemoryPool__max_memory", (DL_FUNC) &_arrow_MemoryPool__max_memory, 1}, + { "_arrow_ipc___Message__body_length", (DL_FUNC) &_arrow_ipc___Message__body_length, 1}, + { "_arrow_ipc___Message__metadata", (DL_FUNC) &_arrow_ipc___Message__metadata, 1}, + { "_arrow_ipc___Message__body", (DL_FUNC) &_arrow_ipc___Message__body, 1}, + { "_arrow_ipc___Message__Verify", (DL_FUNC) &_arrow_ipc___Message__Verify, 1}, + { "_arrow_ipc___Message__type", (DL_FUNC) &_arrow_ipc___Message__type, 1}, + { "_arrow_ipc___Message__Equals", (DL_FUNC) &_arrow_ipc___Message__Equals, 2}, + { "_arrow_ipc___ReadRecordBatch__Message__Schema", (DL_FUNC) &_arrow_ipc___ReadRecordBatch__Message__Schema, 2}, + { "_arrow_ipc___ReadSchema_InputStream", (DL_FUNC) &_arrow_ipc___ReadSchema_InputStream, 1}, + { "_arrow_ipc___MessageReader__Open", (DL_FUNC) &_arrow_ipc___MessageReader__Open, 1}, + { "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC) &_arrow_ipc___MessageReader__ReadNextMessage, 1}, + { "_arrow_ipc___ReadMessage", (DL_FUNC) &_arrow_ipc___ReadMessage, 1}, + { "_arrow_read_parquet_file", (DL_FUNC) &_arrow_read_parquet_file, 1}, + { "_arrow_RecordBatch__num_columns", (DL_FUNC) &_arrow_RecordBatch__num_columns, 1}, + { "_arrow_RecordBatch__num_rows", (DL_FUNC) &_arrow_RecordBatch__num_rows, 1}, + { "_arrow_RecordBatch__schema", (DL_FUNC) &_arrow_RecordBatch__schema, 1}, + { "_arrow_RecordBatch__columns", (DL_FUNC) &_arrow_RecordBatch__columns, 1}, + { "_arrow_RecordBatch__column", (DL_FUNC) &_arrow_RecordBatch__column, 2}, + { "_arrow_RecordBatch__from_dataframe", (DL_FUNC) &_arrow_RecordBatch__from_dataframe, 1}, + { "_arrow_RecordBatch__Equals", (DL_FUNC) &_arrow_RecordBatch__Equals, 2}, + { "_arrow_RecordBatch__RemoveColumn", (DL_FUNC) &_arrow_RecordBatch__RemoveColumn, 2}, + { "_arrow_RecordBatch__column_name", (DL_FUNC) &_arrow_RecordBatch__column_name, 2}, + { "_arrow_RecordBatch__names", (DL_FUNC) &_arrow_RecordBatch__names, 1}, + { "_arrow_RecordBatch__Slice1", (DL_FUNC) &_arrow_RecordBatch__Slice1, 2}, + { "_arrow_RecordBatch__Slice2", (DL_FUNC) &_arrow_RecordBatch__Slice2, 3}, + { "_arrow_ipc___SerializeRecordBatch__Raw", (DL_FUNC) &_arrow_ipc___SerializeRecordBatch__Raw, 1}, + { "_arrow_ipc___ReadRecordBatch__InputStream__Schema", (DL_FUNC) &_arrow_ipc___ReadRecordBatch__InputStream__Schema, 2}, + { "_arrow_RecordBatch__from_arrays", (DL_FUNC) &_arrow_RecordBatch__from_arrays, 2}, + { "_arrow_RecordBatchReader__schema", (DL_FUNC) &_arrow_RecordBatchReader__schema, 1}, + { "_arrow_RecordBatchReader__ReadNext", (DL_FUNC) &_arrow_RecordBatchReader__ReadNext, 1}, + { "_arrow_ipc___RecordBatchStreamReader__Open", (DL_FUNC) &_arrow_ipc___RecordBatchStreamReader__Open, 1}, + { "_arrow_ipc___RecordBatchStreamReader__batches", (DL_FUNC) &_arrow_ipc___RecordBatchStreamReader__batches, 1}, + { "_arrow_ipc___RecordBatchFileReader__schema", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__schema, 1}, + { "_arrow_ipc___RecordBatchFileReader__num_record_batches", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__num_record_batches, 1}, + { "_arrow_ipc___RecordBatchFileReader__ReadRecordBatch", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__ReadRecordBatch, 2}, + { "_arrow_ipc___RecordBatchFileReader__Open", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__Open, 1}, + { "_arrow_Table__from_RecordBatchFileReader", (DL_FUNC) &_arrow_Table__from_RecordBatchFileReader, 1}, + { "_arrow_Table__from_RecordBatchStreamReader", (DL_FUNC) &_arrow_Table__from_RecordBatchStreamReader, 1}, + { "_arrow_ipc___RecordBatchFileReader__batches", (DL_FUNC) &_arrow_ipc___RecordBatchFileReader__batches, 1}, + { "_arrow_ipc___RecordBatchWriter__WriteRecordBatch", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__WriteRecordBatch, 2}, + { "_arrow_ipc___RecordBatchWriter__WriteTable", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__WriteTable, 2}, + { "_arrow_ipc___RecordBatchWriter__Close", (DL_FUNC) &_arrow_ipc___RecordBatchWriter__Close, 1}, + { "_arrow_ipc___RecordBatchFileWriter__Open", (DL_FUNC) &_arrow_ipc___RecordBatchFileWriter__Open, 2}, + { "_arrow_ipc___RecordBatchStreamWriter__Open", (DL_FUNC) &_arrow_ipc___RecordBatchStreamWriter__Open, 2}, + { "_arrow_Table__from_dataframe", (DL_FUNC) &_arrow_Table__from_dataframe, 1}, + { "_arrow_Table__num_columns", (DL_FUNC) &_arrow_Table__num_columns, 1}, + { "_arrow_Table__num_rows", (DL_FUNC) &_arrow_Table__num_rows, 1}, + { "_arrow_Table__schema", (DL_FUNC) &_arrow_Table__schema, 1}, + { "_arrow_Table__column", (DL_FUNC) &_arrow_Table__column, 2}, + { "_arrow_Table__columns", (DL_FUNC) &_arrow_Table__columns, 1}, + { "_arrow_Table__from_dots", (DL_FUNC) &_arrow_Table__from_dots, 2}, + { "_arrow_GetCpuThreadPoolCapacity", (DL_FUNC) &_arrow_GetCpuThreadPoolCapacity, 0}, + { "_arrow_SetCpuThreadPoolCapacity", (DL_FUNC) &_arrow_SetCpuThreadPoolCapacity, 1}, {NULL, NULL, 0} }; -extern "C" void R_init_arrow(DllInfo* dll){ +RcppExport void R_init_arrow(DllInfo* dll){ R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); } From 3b043696075ec7b02ad18a89e8185178ff359ca6 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Mon, 10 Jun 2019 10:10:36 +0200 Subject: [PATCH 15/24] use `\dontrun{}` in examples --- r/R/Field.R | 2 +- r/R/parquet.R | 2 +- r/man/field.Rd | 2 +- r/man/read_parquet.Rd | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/r/R/Field.R b/r/R/Field.R index 440df3db948..5175ee5d154 100644 --- a/r/R/Field.R +++ b/r/R/Field.R @@ -65,7 +65,7 @@ #' #' @examples #' -#' if(arrow_available()){ +#' \dontrun{ #' field("x", int32()) #' } #' diff --git a/r/R/parquet.R b/r/R/parquet.R index 699d28bf76c..d7f389f679f 100644 --- a/r/R/parquet.R +++ b/r/R/parquet.R @@ -31,7 +31,7 @@ #' `TRUE`. #' @examples #' -#' if (arrow_available()) { +#' \dontrun{ #' df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) #' } #' diff --git a/r/man/field.Rd b/r/man/field.Rd index 23532967579..52995a13fa9 100644 --- a/r/man/field.Rd +++ b/r/man/field.Rd @@ -18,7 +18,7 @@ Factory for a \code{arrow::Field} } \examples{ -if(arrow_available()){ +\dontrun{ field("x", int32()) } diff --git a/r/man/read_parquet.Rd b/r/man/read_parquet.Rd index 256a0f2b496..2bce02c5817 100644 --- a/r/man/read_parquet.Rd +++ b/r/man/read_parquet.Rd @@ -27,7 +27,7 @@ This function enables you to read Parquet files into R. } \examples{ -if (arrow_available()) { +\dontrun{ df <- read_parquet(system.file("v0.7.1.parquet", package="arrow")) } From 1df1e3956f644486556bc74391b95e12b4506457 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Mon, 10 Jun 2019 10:13:06 +0200 Subject: [PATCH 16/24] phrase shim message more positively --- r/configure | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/r/configure b/r/configure index 3bb74e38c9c..e063028656a 100755 --- a/r/configure +++ b/r/configure @@ -108,8 +108,8 @@ echo "#include $PKG_TEST_HEADER" | ${CXXCPP} ${CPPFLAGS} ${PKG_CFLAGS} ${CXX11FL # Customize the error if [ $? -ne 0 ]; then echo "------------------------- NOTE ---------------------------" - echo "only installing shim version of the package" - echo "after installation, please run arrow::install_arrow()" + echo "After installation, please run arrow::install_arrow() to install" + echo "required runtime libraries" echo "---------------------------------------------------------" PKG_LIBS="" PKG_CFLAGS="" From bb9eed2debe2baa893f5d65ee44e6d92c99ee30f Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Mon, 10 Jun 2019 10:18:34 +0200 Subject: [PATCH 17/24] not showing diff for generated files [ci skip] --- .gitattributes | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitattributes b/.gitattributes index 4a9f90a0873..fac7bf85a77 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,4 +1,6 @@ r/R/RcppExports.R linguist-generated=true +r/R/arrowExports.R linguist-generated=true r/src/RcppExports.cpp linguist-generated=true +r/src/arrowExports.cpp linguist-generated=true r/man/*.Rd linguist-generated=true From 346978d0851b3ef87a5e1c7a768e106f1cc25f76 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 09:29:47 +0200 Subject: [PATCH 18/24] update docker files. --- ci/docker_build_r.sh | 2 -- r/Dockerfile | 11 +++++------ 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/ci/docker_build_r.sh b/ci/docker_build_r.sh index 7f72cdf4720..6355afa4ee5 100755 --- a/ci/docker_build_r.sh +++ b/ci/docker_build_r.sh @@ -23,8 +23,6 @@ export ARROW_HOME=$CONDA_PREFIX # Build arrow pushd /arrow/r -rm src/RcppExports* -Rscript -e "Rcpp::compileAttributes()" R CMD build --keep-empty-dirs . R CMD INSTALL $(ls | grep arrow_*.tar.gz) diff --git a/r/Dockerfile b/r/Dockerfile index f70d3954b21..6102731d506 100644 --- a/r/Dockerfile +++ b/r/Dockerfile @@ -48,14 +48,10 @@ RUN apt update && \ # R CMD CHECK --as-cran needs pdflatex to build the package manual apt install -y \ texlive-latex-base && \ - # Install vctrs from Github Rscript -e "install.packages('devtools', repos = 'http://cran.rstudio.com')" && \ - Rscript -e "devtools::install_github('romainfrancois/vctrs@bit64')" && \ - Rscript -e "devtools::install_github('r-lib/withr')" && \ - Rscript -e "devtools::install_github('RcppCore/Rcpp')" && \ - # R is not good at picking up dependencies and installing them automatically + Rscript -e "devtools::install_github('romainfrancois/decor')" && \ Rscript -e "install.packages(c( \ - 'Rcpp', \ + 'Rcpp', 'dplyr', 'stringr', 'glue', 'vctrs', \ 'purrr', \ 'assertthat', \ 'fs', \ @@ -67,6 +63,9 @@ RUN apt update && \ 'lubridate'), \ repos = 'http://cran.rstudio.com')" +# So that arrowExports.* files are generated +ENV ARROW_R_DEV=TRUE + # Tell R where it can find the source code for arrow ENV PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:/build/cpp/src/arrow:/opt/conda/lib/pkgconfig ENV LD_LIBRARY_PATH=/opt/conda/lib/:/build/cpp/src/arrow:/arrow/r/src From 238fa14db0c30bf93b2243ce4a05028bc6e6ac0d Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 09:44:22 +0200 Subject: [PATCH 19/24] rm message about ARROW_R_DEV not being set --- r/configure | 2 -- 1 file changed, 2 deletions(-) diff --git a/r/configure b/r/configure index e063028656a..f38026cec0e 100755 --- a/r/configure +++ b/r/configure @@ -37,8 +37,6 @@ PKG_LIBS="-larrow -lparquet" if [ "$ARROW_R_DEV" == "TRUE" ]; then echo "*** Generating code with data-raw/codegen.R" ${R_HOME}/bin/Rscript data-raw/codegen.R -else - echo "Environment variable $$ARROW_R_DEV not set to TRUE, skip code generation" fi # Note that cflags may be empty in case of success From b8a6576b377db23908a7679588e57e96d122ee29 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 09:45:34 +0200 Subject: [PATCH 20/24] no need for stringr --- r/data-raw/codegen.R | 1 - 1 file changed, 1 deletion(-) diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index 7dd77159412..dc814270d56 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -20,7 +20,6 @@ suppressPackageStartupMessages({ library(decor) library(dplyr) - library(stringr) library(purrr) library(glue) }) From 496eaf521e74eed5b88a8e0a98dd872c03a755ff Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 09:51:52 +0200 Subject: [PATCH 21/24] when brew is available but apache-arrow is not installed, install it --- r/configure | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/r/configure b/r/configure index f38026cec0e..4b3484fcbe7 100755 --- a/r/configure +++ b/r/configure @@ -69,14 +69,12 @@ else BREWDIR=$(brew --prefix) if brew ls --versions apache-arrow > /dev/null; then - echo "Found brew install of apache-arrow formula" - PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include" - PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" - else - echo "apache-arrow brew formula not installed :/" - PKG_CFLAGS="" - PKG_LIBS="" + # right now, we need HEAD version + brew install apache-arrow --HEAD fi + + PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include" + PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS" else echo "brew is not available, trying autobrew" curl -sfL "https://jeroen.github.io/autobrew/$PKG_BREW_NAME" > autobrew From 9a1b3e6659eff44a1116e02fa1ba71805beca550 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 09:58:03 +0200 Subject: [PATCH 22/24] glue() not needed here --- r/data-raw/codegen.R | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index dc814270d56..2649b61bbb9 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -116,7 +116,7 @@ RcppExport void R_init_arrow(DllInfo* dll){{ ') ) -message(glue("*** > generated file `src/arrowExports.cpp`")) +message("*** > generated file `src/arrowExports.cpp`") r_functions <- decorations %>% select(name, return_type, args) %>% @@ -150,4 +150,4 @@ writeLines(con = "R/arrowExports.R", glue::glue(' {r_functions} ')) -message(glue("*** > generated file `R/arrowExports.R`")) +message("*** > generated file `R/arrowExports.R`") From 418fc2d0904982f7805c8c23ff73aacd9b9072c2 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 10:11:41 +0200 Subject: [PATCH 23/24] mention codegen in the README --- r/README.Rmd | 6 ++++-- r/README.md | 31 +++++++++++++++++-------------- r/data-raw/codegen.R | 19 +++++++++++++++++++ 3 files changed, 40 insertions(+), 16 deletions(-) diff --git a/r/README.Rmd b/r/README.Rmd index 5b837ef4c8e..4b6ab143c71 100644 --- a/r/README.Rmd +++ b/r/README.Rmd @@ -88,8 +88,7 @@ For any other build/configuration challenges, see the [C++ developer guide](http ```{r} library(arrow) -tib <- tibble::tibble(x = 1:10, y = rnorm(10)) -tab <- table(tib) +tab <- arrow::table(x = 1:10, y = rnorm(10)) tab$schema tab as_tibble(tab) @@ -104,6 +103,9 @@ install.packages("devtools") devtools::install_dev_deps() ``` +If you change C++ code, you need to set the `ARROW_R_DEV` environment variable to `TRUE`, e.g. +in your `~/.Renviron` so that the `data-raw/codegen.R` file is used for code generation. + ### Useful functions ```r diff --git a/r/README.md b/r/README.md index de134651819..c87b8c685b6 100644 --- a/r/README.md +++ b/r/README.md @@ -97,8 +97,7 @@ library(arrow) #> #> array, table -tib <- tibble::tibble(x = 1:10, y = rnorm(10)) -tab <- table(tib) +tab <- arrow::table(x = 1:10, y = rnorm(10)) tab$schema #> arrow::Schema #> x: int32 @@ -107,18 +106,18 @@ tab #> arrow::Table as_tibble(tab) #> # A tibble: 10 x 2 -#> x y -#> -#> 1 1 0.912 -#> 2 2 1.31 -#> 3 3 -1.47 -#> 4 4 -0.332 -#> 5 5 -1.60 -#> 6 6 -2.51 -#> 7 7 0.903 -#> 8 8 -2.44 -#> 9 9 0.990 -#> 10 10 -0.0164 +#> x y +#> +#> 1 1 0.524 +#> 2 2 -0.606 +#> 3 3 -0.655 +#> 4 4 1.37 +#> 5 5 1.53 +#> 6 6 1.96 +#> 7 7 1.80 +#> 8 8 1.27 +#> 9 9 0.698 +#> 10 10 -0.661 ``` ## Developing @@ -132,6 +131,10 @@ install.packages("devtools") devtools::install_dev_deps() ``` +If you change C++ code, you need to set the `ARROW_R_DEV` environment +variable to `TRUE`, e.g.  in your `~/.Renviron` so that the +`data-raw/codegen.R` file is used for code generation. + ### Useful functions ``` r diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index 2649b61bbb9..c53cbdc9d1e 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -15,6 +15,25 @@ # specific language governing permissions and limitations # under the License. +# This file is used to generate code in the files +# src/arrowExports.cpp and R/arrowExports.R +# +# This is similar to what Rcpp::compileAttributes() would do, +# with some arrow specific changes. +# +# Functions are decorated with [[arrow::export]] instead of [[Rcpp::export]] +# and the generated code adds a layer of protection so that +# the arrow package can be installed even when libarrow is not +# +# All the C++ code should be guarded by +# +# #if defined(ARROW_R_WITH_ARROW) +# // [[arrow::export]] +# std::shared_ptr some_function_using_arrow_api(){ +# ... +# } +# #endif + suppressPackageStartupMessages({ # pak::pkg_install("romainfrancois/decor") library(decor) From d13dbfbeaec6b0647f37eb2bb78256d417709fe0 Mon Sep 17 00:00:00 2001 From: Romain Francois Date: Tue, 11 Jun 2019 10:27:05 +0200 Subject: [PATCH 24/24] update error message to mention arrow::install_arrow() --- r/data-raw/codegen.R | 2 +- r/src/arrowExports.cpp | 416 ++++++++++++++++++++--------------------- 2 files changed, 209 insertions(+), 209 deletions(-) diff --git a/r/data-raw/codegen.R b/r/data-raw/codegen.R index c53cbdc9d1e..17fa0f0e489 100644 --- a/r/data-raw/codegen.R +++ b/r/data-raw/codegen.R @@ -82,7 +82,7 @@ cpp_functions_definitions <- decorations %>% }} #else RcppExport SEXP _arrow_{name}({sexp_params}){{ - \tRf_error("arrow C++ library not available. Cannot call {name}(). "); + \tRf_error("Cannot call {name}(). Please use arrow::install_arrow() to install required runtime libraries. "); }} #endif diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp index a1aef203aa3..0ddac30f517 100644 --- a/r/src/arrowExports.cpp +++ b/r/src/arrowExports.cpp @@ -16,7 +16,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__Slice1(SEXP array_sexp, SEXP offset_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__Slice1(). "); + Rf_error("Cannot call Array__Slice1(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -33,7 +33,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__Slice2(SEXP array_sexp, SEXP offset_sexp, SEXP length_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__Slice2(). "); + Rf_error("Cannot call Array__Slice2(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -49,7 +49,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__IsNull(SEXP x_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__IsNull(). "); + Rf_error("Cannot call Array__IsNull(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -65,7 +65,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__IsValid(SEXP x_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__IsValid(). "); + Rf_error("Cannot call Array__IsValid(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -80,7 +80,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__length(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__length(). "); + Rf_error("Cannot call Array__length(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -95,7 +95,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__offset(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__offset(). "); + Rf_error("Cannot call Array__offset(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -110,7 +110,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__null_count(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__null_count(). "); + Rf_error("Cannot call Array__null_count(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -125,7 +125,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__type(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__type(). "); + Rf_error("Cannot call Array__type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -140,7 +140,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__ToString(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__ToString(). "); + Rf_error("Cannot call Array__ToString(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -155,7 +155,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__type_id(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__type_id(). "); + Rf_error("Cannot call Array__type_id(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -171,7 +171,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__Equals(). "); + Rf_error("Cannot call Array__Equals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -187,7 +187,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__ApproxEquals(SEXP lhs_sexp, SEXP rhs_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__ApproxEquals(). "); + Rf_error("Cannot call Array__ApproxEquals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -202,7 +202,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__data(SEXP array_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__data(). "); + Rf_error("Cannot call Array__data(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -221,7 +221,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__RangeEquals(SEXP self_sexp, SEXP other_sexp, SEXP start_idx_sexp, SEXP end_idx_sexp, SEXP other_start_idx_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__RangeEquals(). "); + Rf_error("Cannot call Array__RangeEquals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -236,7 +236,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__Mask(SEXP array_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__Mask(). "); + Rf_error("Cannot call Array__Mask(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -251,7 +251,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryArray__indices(SEXP array_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryArray__indices(). "); + Rf_error("Cannot call DictionaryArray__indices(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -266,7 +266,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryArray__dictionary(SEXP array_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryArray__dictionary(). "); + Rf_error("Cannot call DictionaryArray__dictionary(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -281,7 +281,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__as_vector(SEXP array_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__as_vector(). "); + Rf_error("Cannot call Array__as_vector(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -296,7 +296,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__as_vector(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__as_vector(). "); + Rf_error("Cannot call ChunkedArray__as_vector(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -312,7 +312,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__to_dataframe(SEXP batch_sexp, SEXP use_threads_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__to_dataframe(). "); + Rf_error("Cannot call RecordBatch__to_dataframe(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -328,7 +328,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__to_dataframe(SEXP table_sexp, SEXP use_threads_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__to_dataframe(). "); + Rf_error("Cannot call Table__to_dataframe(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -343,7 +343,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__infer_type(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__infer_type(). "); + Rf_error("Cannot call Array__infer_type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -359,7 +359,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__from_vector(SEXP x_sexp, SEXP s_type_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__from_vector(). "); + Rf_error("Cannot call Array__from_vector(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -375,7 +375,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__from_list(SEXP chunks_sexp, SEXP s_type_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__from_list(). "); + Rf_error("Cannot call ChunkedArray__from_list(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -390,7 +390,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ArrayData__get_type(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call ArrayData__get_type(). "); + Rf_error("Cannot call ArrayData__get_type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -405,7 +405,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ArrayData__get_length(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call ArrayData__get_length(). "); + Rf_error("Cannot call ArrayData__get_length(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -420,7 +420,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ArrayData__get_null_count(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call ArrayData__get_null_count(). "); + Rf_error("Cannot call ArrayData__get_null_count(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -435,7 +435,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ArrayData__get_offset(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call ArrayData__get_offset(). "); + Rf_error("Cannot call ArrayData__get_offset(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -450,7 +450,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ArrayData__buffers(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call ArrayData__buffers(). "); + Rf_error("Cannot call ArrayData__buffers(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -465,7 +465,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Buffer__is_mutable(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call Buffer__is_mutable(). "); + Rf_error("Cannot call Buffer__is_mutable(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -481,7 +481,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Buffer__ZeroPadding(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call Buffer__ZeroPadding(). "); + Rf_error("Cannot call Buffer__ZeroPadding(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -496,7 +496,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Buffer__capacity(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call Buffer__capacity(). "); + Rf_error("Cannot call Buffer__capacity(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -511,7 +511,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Buffer__size(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call Buffer__size(). "); + Rf_error("Cannot call Buffer__size(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -526,7 +526,7 @@ END_RCPP } #else RcppExport SEXP _arrow_r___RBuffer__initialize(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call r___RBuffer__initialize(). "); + Rf_error("Cannot call r___RBuffer__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -541,7 +541,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__length(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__length(). "); + Rf_error("Cannot call ChunkedArray__length(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -556,7 +556,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__null_count(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__null_count(). "); + Rf_error("Cannot call ChunkedArray__null_count(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -571,7 +571,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__num_chunks(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__num_chunks(). "); + Rf_error("Cannot call ChunkedArray__num_chunks(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -587,7 +587,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__chunk(SEXP chunked_array_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunk(). "); + Rf_error("Cannot call ChunkedArray__chunk(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -602,7 +602,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__chunks(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__chunks(). "); + Rf_error("Cannot call ChunkedArray__chunks(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -617,7 +617,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__type(SEXP chunked_array_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__type(). "); + Rf_error("Cannot call ChunkedArray__type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -633,7 +633,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkArray__Slice1(SEXP chunked_array_sexp, SEXP offset_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice1(). "); + Rf_error("Cannot call ChunkArray__Slice1(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -650,7 +650,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkArray__Slice2(SEXP chunked_array_sexp, SEXP offset_sexp, SEXP length_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkArray__Slice2(). "); + Rf_error("Cannot call ChunkArray__Slice2(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -665,7 +665,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Column__length(SEXP column_sexp){ - Rf_error("arrow C++ library not available. Cannot call Column__length(). "); + Rf_error("Cannot call Column__length(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -680,7 +680,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Column__null_count(SEXP column_sexp){ - Rf_error("arrow C++ library not available. Cannot call Column__null_count(). "); + Rf_error("Cannot call Column__null_count(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -695,7 +695,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Column__type(SEXP column_sexp){ - Rf_error("arrow C++ library not available. Cannot call Column__type(). "); + Rf_error("Cannot call Column__type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -710,7 +710,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Column__data(SEXP column_sexp){ - Rf_error("arrow C++ library not available. Cannot call Column__data(). "); + Rf_error("Cannot call Column__data(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -725,7 +725,7 @@ END_RCPP } #else RcppExport SEXP _arrow_util___Codec__Create(SEXP codec_sexp){ - Rf_error("arrow C++ library not available. Cannot call util___Codec__Create(). "); + Rf_error("Cannot call util___Codec__Create(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -741,7 +741,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___CompressedOutputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___CompressedOutputStream__Make(). "); + Rf_error("Cannot call io___CompressedOutputStream__Make(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -757,7 +757,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___CompressedInputStream__Make(SEXP codec_sexp, SEXP raw_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___CompressedInputStream__Make(). "); + Rf_error("Cannot call io___CompressedInputStream__Make(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -774,7 +774,7 @@ END_RCPP } #else RcppExport SEXP _arrow_compute___CastOptions__initialize(SEXP allow_int_overflow_sexp, SEXP allow_time_truncate_sexp, SEXP allow_float_truncate_sexp){ - Rf_error("arrow C++ library not available. Cannot call compute___CastOptions__initialize(). "); + Rf_error("Cannot call compute___CastOptions__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -791,7 +791,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Array__cast(SEXP array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call Array__cast(). "); + Rf_error("Cannot call Array__cast(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -808,7 +808,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ChunkedArray__cast(SEXP chunked_array_sexp, SEXP target_type_sexp, SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call ChunkedArray__cast(). "); + Rf_error("Cannot call ChunkedArray__cast(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -825,7 +825,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__cast(SEXP batch_sexp, SEXP schema_sexp, SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__cast(). "); + Rf_error("Cannot call RecordBatch__cast(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -842,7 +842,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__cast(SEXP table_sexp, SEXP schema_sexp, SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__cast(). "); + Rf_error("Cannot call Table__cast(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -857,7 +857,7 @@ END_RCPP } #else RcppExport SEXP _arrow_csv___ReadOptions__initialize(SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call csv___ReadOptions__initialize(). "); + Rf_error("Cannot call csv___ReadOptions__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -872,7 +872,7 @@ END_RCPP } #else RcppExport SEXP _arrow_csv___ParseOptions__initialize(SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call csv___ParseOptions__initialize(). "); + Rf_error("Cannot call csv___ParseOptions__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -887,7 +887,7 @@ END_RCPP } #else RcppExport SEXP _arrow_csv___ConvertOptions__initialize(SEXP options_sexp){ - Rf_error("arrow C++ library not available. Cannot call csv___ConvertOptions__initialize(). "); + Rf_error("Cannot call csv___ConvertOptions__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -905,7 +905,7 @@ END_RCPP } #else RcppExport SEXP _arrow_csv___TableReader__Make(SEXP input_sexp, SEXP read_options_sexp, SEXP parse_options_sexp, SEXP convert_options_sexp){ - Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Make(). "); + Rf_error("Cannot call csv___TableReader__Make(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -920,7 +920,7 @@ END_RCPP } #else RcppExport SEXP _arrow_csv___TableReader__Read(SEXP table_reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call csv___TableReader__Read(). "); + Rf_error("Cannot call csv___TableReader__Read(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -935,7 +935,7 @@ END_RCPP } #else RcppExport SEXP _arrow_shared_ptr_is_null(SEXP xp_sexp){ - Rf_error("arrow C++ library not available. Cannot call shared_ptr_is_null(). "); + Rf_error("Cannot call shared_ptr_is_null(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -950,7 +950,7 @@ END_RCPP } #else RcppExport SEXP _arrow_unique_ptr_is_null(SEXP xp_sexp){ - Rf_error("arrow C++ library not available. Cannot call unique_ptr_is_null(). "); + Rf_error("Cannot call unique_ptr_is_null(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -964,7 +964,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Int8__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Int8__initialize(). "); + Rf_error("Cannot call Int8__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -978,7 +978,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Int16__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Int16__initialize(). "); + Rf_error("Cannot call Int16__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -992,7 +992,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Int32__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Int32__initialize(). "); + Rf_error("Cannot call Int32__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1006,7 +1006,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Int64__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Int64__initialize(). "); + Rf_error("Cannot call Int64__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1020,7 +1020,7 @@ END_RCPP } #else RcppExport SEXP _arrow_UInt8__initialize(){ - Rf_error("arrow C++ library not available. Cannot call UInt8__initialize(). "); + Rf_error("Cannot call UInt8__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1034,7 +1034,7 @@ END_RCPP } #else RcppExport SEXP _arrow_UInt16__initialize(){ - Rf_error("arrow C++ library not available. Cannot call UInt16__initialize(). "); + Rf_error("Cannot call UInt16__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1048,7 +1048,7 @@ END_RCPP } #else RcppExport SEXP _arrow_UInt32__initialize(){ - Rf_error("arrow C++ library not available. Cannot call UInt32__initialize(). "); + Rf_error("Cannot call UInt32__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1062,7 +1062,7 @@ END_RCPP } #else RcppExport SEXP _arrow_UInt64__initialize(){ - Rf_error("arrow C++ library not available. Cannot call UInt64__initialize(). "); + Rf_error("Cannot call UInt64__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1076,7 +1076,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Float16__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Float16__initialize(). "); + Rf_error("Cannot call Float16__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1090,7 +1090,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Float32__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Float32__initialize(). "); + Rf_error("Cannot call Float32__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1104,7 +1104,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Float64__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Float64__initialize(). "); + Rf_error("Cannot call Float64__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1118,7 +1118,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Boolean__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Boolean__initialize(). "); + Rf_error("Cannot call Boolean__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1132,7 +1132,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Utf8__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Utf8__initialize(). "); + Rf_error("Cannot call Utf8__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1146,7 +1146,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Date32__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Date32__initialize(). "); + Rf_error("Cannot call Date32__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1160,7 +1160,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Date64__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Date64__initialize(). "); + Rf_error("Cannot call Date64__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1174,7 +1174,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Null__initialize(){ - Rf_error("arrow C++ library not available. Cannot call Null__initialize(). "); + Rf_error("Cannot call Null__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1190,7 +1190,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scale_sexp){ - Rf_error("arrow C++ library not available. Cannot call Decimal128Type__initialize(). "); + Rf_error("Cannot call Decimal128Type__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1205,7 +1205,7 @@ END_RCPP } #else RcppExport SEXP _arrow_FixedSizeBinary__initialize(SEXP byte_width_sexp){ - Rf_error("arrow C++ library not available. Cannot call FixedSizeBinary__initialize(). "); + Rf_error("Cannot call FixedSizeBinary__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1220,7 +1220,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Timestamp__initialize1(SEXP unit_sexp){ - Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize1(). "); + Rf_error("Cannot call Timestamp__initialize1(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1236,7 +1236,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Timestamp__initialize2(SEXP unit_sexp, SEXP timezone_sexp){ - Rf_error("arrow C++ library not available. Cannot call Timestamp__initialize2(). "); + Rf_error("Cannot call Timestamp__initialize2(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1251,7 +1251,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Time32__initialize(SEXP unit_sexp){ - Rf_error("arrow C++ library not available. Cannot call Time32__initialize(). "); + Rf_error("Cannot call Time32__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1266,7 +1266,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Time64__initialize(SEXP unit_sexp){ - Rf_error("arrow C++ library not available. Cannot call Time64__initialize(). "); + Rf_error("Cannot call Time64__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1281,7 +1281,7 @@ END_RCPP } #else RcppExport SEXP _arrow_list__(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call list__(). "); + Rf_error("Cannot call list__(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1296,7 +1296,7 @@ END_RCPP } #else RcppExport SEXP _arrow_struct_(SEXP fields_sexp){ - Rf_error("arrow C++ library not available. Cannot call struct_(). "); + Rf_error("Cannot call struct_(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1311,7 +1311,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__ToString(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__ToString(). "); + Rf_error("Cannot call DataType__ToString(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1326,7 +1326,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__name(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__name(). "); + Rf_error("Cannot call DataType__name(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1342,7 +1342,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__Equals(SEXP lhs_sexp, SEXP rhs_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__Equals(). "); + Rf_error("Cannot call DataType__Equals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1357,7 +1357,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__num_children(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__num_children(). "); + Rf_error("Cannot call DataType__num_children(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1372,7 +1372,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__children_pointer(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__children_pointer(). "); + Rf_error("Cannot call DataType__children_pointer(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1387,7 +1387,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DataType__id(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DataType__id(). "); + Rf_error("Cannot call DataType__id(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1402,7 +1402,7 @@ END_RCPP } #else RcppExport SEXP _arrow_schema_(SEXP fields_sexp){ - Rf_error("arrow C++ library not available. Cannot call schema_(). "); + Rf_error("Cannot call schema_(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1417,7 +1417,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Schema__ToString(SEXP s_sexp){ - Rf_error("arrow C++ library not available. Cannot call Schema__ToString(). "); + Rf_error("Cannot call Schema__ToString(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1432,7 +1432,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Schema__num_fields(SEXP s_sexp){ - Rf_error("arrow C++ library not available. Cannot call Schema__num_fields(). "); + Rf_error("Cannot call Schema__num_fields(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1448,7 +1448,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Schema__field(SEXP s_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call Schema__field(). "); + Rf_error("Cannot call Schema__field(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1463,7 +1463,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Schema__names(SEXP schema_sexp){ - Rf_error("arrow C++ library not available. Cannot call Schema__names(). "); + Rf_error("Cannot call Schema__names(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1478,7 +1478,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ListType__ToString(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call ListType__ToString(). "); + Rf_error("Cannot call ListType__ToString(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1493,7 +1493,7 @@ END_RCPP } #else RcppExport SEXP _arrow_FixedWidthType__bit_width(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call FixedWidthType__bit_width(). "); + Rf_error("Cannot call FixedWidthType__bit_width(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1508,7 +1508,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DateType__unit(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DateType__unit(). "); + Rf_error("Cannot call DateType__unit(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1523,7 +1523,7 @@ END_RCPP } #else RcppExport SEXP _arrow_TimeType__unit(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call TimeType__unit(). "); + Rf_error("Cannot call TimeType__unit(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1538,7 +1538,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DecimalType__precision(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DecimalType__precision(). "); + Rf_error("Cannot call DecimalType__precision(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1553,7 +1553,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DecimalType__scale(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DecimalType__scale(). "); + Rf_error("Cannot call DecimalType__scale(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1568,7 +1568,7 @@ END_RCPP } #else RcppExport SEXP _arrow_TimestampType__timezone(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call TimestampType__timezone(). "); + Rf_error("Cannot call TimestampType__timezone(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1583,7 +1583,7 @@ END_RCPP } #else RcppExport SEXP _arrow_TimestampType__unit(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call TimestampType__unit(). "); + Rf_error("Cannot call TimestampType__unit(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1600,7 +1600,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryType__initialize(SEXP index_type_sexp, SEXP value_type_sexp, SEXP ordered_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryType__initialize(). "); + Rf_error("Cannot call DictionaryType__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1615,7 +1615,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryType__index_type(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryType__index_type(). "); + Rf_error("Cannot call DictionaryType__index_type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1630,7 +1630,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryType__value_type(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryType__value_type(). "); + Rf_error("Cannot call DictionaryType__value_type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1645,7 +1645,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryType__name(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryType__name(). "); + Rf_error("Cannot call DictionaryType__name(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1660,7 +1660,7 @@ END_RCPP } #else RcppExport SEXP _arrow_DictionaryType__ordered(SEXP type_sexp){ - Rf_error("arrow C++ library not available. Cannot call DictionaryType__ordered(). "); + Rf_error("Cannot call DictionaryType__ordered(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1677,7 +1677,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableWriter__SetDescription(SEXP writer_sexp, SEXP description_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetDescription(). "); + Rf_error("Cannot call ipc___feather___TableWriter__SetDescription(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1694,7 +1694,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableWriter__SetNumRows(SEXP writer_sexp, SEXP num_rows_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__SetNumRows(). "); + Rf_error("Cannot call ipc___feather___TableWriter__SetNumRows(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1712,7 +1712,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableWriter__Append(SEXP writer_sexp, SEXP name_sexp, SEXP values_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Append(). "); + Rf_error("Cannot call ipc___feather___TableWriter__Append(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1728,7 +1728,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableWriter__Finalize(SEXP writer_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Finalize(). "); + Rf_error("Cannot call ipc___feather___TableWriter__Finalize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1743,7 +1743,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableWriter__Open(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableWriter__Open(). "); + Rf_error("Cannot call ipc___feather___TableWriter__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1760,7 +1760,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___TableWriter__RecordBatch__WriteFeather(SEXP writer_sexp, SEXP batch_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___TableWriter__RecordBatch__WriteFeather(). "); + Rf_error("Cannot call ipc___TableWriter__RecordBatch__WriteFeather(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1775,7 +1775,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__GetDescription(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetDescription(). "); + Rf_error("Cannot call ipc___feather___TableReader__GetDescription(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1790,7 +1790,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__HasDescription(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__HasDescription(). "); + Rf_error("Cannot call ipc___feather___TableReader__HasDescription(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1805,7 +1805,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__version(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__version(). "); + Rf_error("Cannot call ipc___feather___TableReader__version(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1820,7 +1820,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__num_rows(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_rows(). "); + Rf_error("Cannot call ipc___feather___TableReader__num_rows(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1835,7 +1835,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__num_columns(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__num_columns(). "); + Rf_error("Cannot call ipc___feather___TableReader__num_columns(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1851,7 +1851,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumnName(SEXP reader_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumnName(). "); + Rf_error("Cannot call ipc___feather___TableReader__GetColumnName(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1867,7 +1867,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__GetColumn(SEXP reader_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__GetColumn(). "); + Rf_error("Cannot call ipc___feather___TableReader__GetColumn(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1883,7 +1883,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__Read(SEXP reader_sexp, SEXP columns_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Read(). "); + Rf_error("Cannot call ipc___feather___TableReader__Read(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1898,7 +1898,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___feather___TableReader__Open(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___feather___TableReader__Open(). "); + Rf_error("Cannot call ipc___feather___TableReader__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1915,7 +1915,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__initialize(SEXP name_sexp, SEXP field_sexp, SEXP nullable_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__initialize(). "); + Rf_error("Cannot call Field__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1930,7 +1930,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__ToString(SEXP field_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__ToString(). "); + Rf_error("Cannot call Field__ToString(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1945,7 +1945,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__name(SEXP field_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__name(). "); + Rf_error("Cannot call Field__name(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1961,7 +1961,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__Equals(SEXP field_sexp, SEXP other_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__Equals(). "); + Rf_error("Cannot call Field__Equals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1976,7 +1976,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__nullable(SEXP field_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__nullable(). "); + Rf_error("Cannot call Field__nullable(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -1991,7 +1991,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Field__type(SEXP field_sexp){ - Rf_error("arrow C++ library not available. Cannot call Field__type(). "); + Rf_error("Cannot call Field__type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2007,7 +2007,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___Readable__Read(SEXP x_sexp, SEXP nbytes_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___Readable__Read(). "); + Rf_error("Cannot call io___Readable__Read(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2023,7 +2023,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___InputStream__Close(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___InputStream__Close(). "); + Rf_error("Cannot call io___InputStream__Close(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2039,7 +2039,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___OutputStream__Close(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Close(). "); + Rf_error("Cannot call io___OutputStream__Close(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2054,7 +2054,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___RandomAccessFile__GetSize(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__GetSize(). "); + Rf_error("Cannot call io___RandomAccessFile__GetSize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2069,7 +2069,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___RandomAccessFile__supports_zero_copy(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__supports_zero_copy(). "); + Rf_error("Cannot call io___RandomAccessFile__supports_zero_copy(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2086,7 +2086,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___RandomAccessFile__Seek(SEXP x_sexp, SEXP position_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Seek(). "); + Rf_error("Cannot call io___RandomAccessFile__Seek(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2101,7 +2101,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___RandomAccessFile__Tell(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___RandomAccessFile__Tell(). "); + Rf_error("Cannot call io___RandomAccessFile__Tell(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2117,7 +2117,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___MemoryMappedFile__Create(SEXP path_sexp, SEXP size_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Create(). "); + Rf_error("Cannot call io___MemoryMappedFile__Create(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2133,7 +2133,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___MemoryMappedFile__Open(SEXP path_sexp, SEXP mode_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Open(). "); + Rf_error("Cannot call io___MemoryMappedFile__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2150,7 +2150,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___MemoryMappedFile__Resize(SEXP x_sexp, SEXP size_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___MemoryMappedFile__Resize(). "); + Rf_error("Cannot call io___MemoryMappedFile__Resize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2165,7 +2165,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___ReadableFile__Open(SEXP path_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___ReadableFile__Open(). "); + Rf_error("Cannot call io___ReadableFile__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2180,7 +2180,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferReader__initialize(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferReader__initialize(). "); + Rf_error("Cannot call io___BufferReader__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2197,7 +2197,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___Writable__write(SEXP stream_sexp, SEXP buf_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___Writable__write(). "); + Rf_error("Cannot call io___Writable__write(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2212,7 +2212,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___OutputStream__Tell(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___OutputStream__Tell(). "); + Rf_error("Cannot call io___OutputStream__Tell(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2227,7 +2227,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___FileOutputStream__Open(SEXP path_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___FileOutputStream__Open(). "); + Rf_error("Cannot call io___FileOutputStream__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2242,7 +2242,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferOutputStream__Create(SEXP initial_capacity_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Create(). "); + Rf_error("Cannot call io___BufferOutputStream__Create(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2257,7 +2257,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferOutputStream__capacity(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__capacity(). "); + Rf_error("Cannot call io___BufferOutputStream__capacity(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2272,7 +2272,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferOutputStream__Finish(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Finish(). "); + Rf_error("Cannot call io___BufferOutputStream__Finish(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2287,7 +2287,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferOutputStream__Tell(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Tell(). "); + Rf_error("Cannot call io___BufferOutputStream__Tell(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2304,7 +2304,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___BufferOutputStream__Write(SEXP stream_sexp, SEXP bytes_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___BufferOutputStream__Write(). "); + Rf_error("Cannot call io___BufferOutputStream__Write(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2318,7 +2318,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___MockOutputStream__initialize(){ - Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__initialize(). "); + Rf_error("Cannot call io___MockOutputStream__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2333,7 +2333,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___MockOutputStream__GetExtentBytesWritten(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___MockOutputStream__GetExtentBytesWritten(). "); + Rf_error("Cannot call io___MockOutputStream__GetExtentBytesWritten(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2348,7 +2348,7 @@ END_RCPP } #else RcppExport SEXP _arrow_io___FixedSizeBufferWriter__initialize(SEXP buffer_sexp){ - Rf_error("arrow C++ library not available. Cannot call io___FixedSizeBufferWriter__initialize(). "); + Rf_error("Cannot call io___FixedSizeBufferWriter__initialize(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2362,7 +2362,7 @@ END_RCPP } #else RcppExport SEXP _arrow_MemoryPool__default(){ - Rf_error("arrow C++ library not available. Cannot call MemoryPool__default(). "); + Rf_error("Cannot call MemoryPool__default(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2377,7 +2377,7 @@ END_RCPP } #else RcppExport SEXP _arrow_MemoryPool__bytes_allocated(SEXP pool_sexp){ - Rf_error("arrow C++ library not available. Cannot call MemoryPool__bytes_allocated(). "); + Rf_error("Cannot call MemoryPool__bytes_allocated(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2392,7 +2392,7 @@ END_RCPP } #else RcppExport SEXP _arrow_MemoryPool__max_memory(SEXP pool_sexp){ - Rf_error("arrow C++ library not available. Cannot call MemoryPool__max_memory(). "); + Rf_error("Cannot call MemoryPool__max_memory(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2407,7 +2407,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__body_length(SEXP message_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__body_length(). "); + Rf_error("Cannot call ipc___Message__body_length(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2422,7 +2422,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__metadata(SEXP message_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__metadata(). "); + Rf_error("Cannot call ipc___Message__metadata(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2437,7 +2437,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__body(SEXP message_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__body(). "); + Rf_error("Cannot call ipc___Message__body(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2452,7 +2452,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__Verify(SEXP message_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__Verify(). "); + Rf_error("Cannot call ipc___Message__Verify(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2467,7 +2467,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__type(SEXP message_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__type(). "); + Rf_error("Cannot call ipc___Message__type(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2483,7 +2483,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___Message__Equals(SEXP x_sexp, SEXP y_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___Message__Equals(). "); + Rf_error("Cannot call ipc___Message__Equals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2499,7 +2499,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___ReadRecordBatch__Message__Schema(SEXP message_sexp, SEXP schema_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__Message__Schema(). "); + Rf_error("Cannot call ipc___ReadRecordBatch__Message__Schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2514,7 +2514,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___ReadSchema_InputStream(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___ReadSchema_InputStream(). "); + Rf_error("Cannot call ipc___ReadSchema_InputStream(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2529,7 +2529,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___MessageReader__Open(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__Open(). "); + Rf_error("Cannot call ipc___MessageReader__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2544,7 +2544,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___MessageReader__ReadNextMessage(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___MessageReader__ReadNextMessage(). "); + Rf_error("Cannot call ipc___MessageReader__ReadNextMessage(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2559,7 +2559,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___ReadMessage(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___ReadMessage(). "); + Rf_error("Cannot call ipc___ReadMessage(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2574,7 +2574,7 @@ END_RCPP } #else RcppExport SEXP _arrow_read_parquet_file(SEXP filename_sexp){ - Rf_error("arrow C++ library not available. Cannot call read_parquet_file(). "); + Rf_error("Cannot call read_parquet_file(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2589,7 +2589,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__num_columns(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_columns(). "); + Rf_error("Cannot call RecordBatch__num_columns(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2604,7 +2604,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__num_rows(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__num_rows(). "); + Rf_error("Cannot call RecordBatch__num_rows(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2619,7 +2619,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__schema(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__schema(). "); + Rf_error("Cannot call RecordBatch__schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2634,7 +2634,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__columns(SEXP batch_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__columns(). "); + Rf_error("Cannot call RecordBatch__columns(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2650,7 +2650,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__column(SEXP batch_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__column(). "); + Rf_error("Cannot call RecordBatch__column(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2665,7 +2665,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__from_dataframe(SEXP tbl_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_dataframe(). "); + Rf_error("Cannot call RecordBatch__from_dataframe(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2681,7 +2681,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__Equals(SEXP self_sexp, SEXP other_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__Equals(). "); + Rf_error("Cannot call RecordBatch__Equals(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2697,7 +2697,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__RemoveColumn(SEXP batch_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__RemoveColumn(). "); + Rf_error("Cannot call RecordBatch__RemoveColumn(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2713,7 +2713,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__column_name(SEXP batch_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__column_name(). "); + Rf_error("Cannot call RecordBatch__column_name(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2728,7 +2728,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__names(SEXP batch_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__names(). "); + Rf_error("Cannot call RecordBatch__names(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2744,7 +2744,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__Slice1(SEXP self_sexp, SEXP offset_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice1(). "); + Rf_error("Cannot call RecordBatch__Slice1(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2761,7 +2761,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__Slice2(SEXP self_sexp, SEXP offset_sexp, SEXP length_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__Slice2(). "); + Rf_error("Cannot call RecordBatch__Slice2(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2776,7 +2776,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___SerializeRecordBatch__Raw(SEXP batch_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___SerializeRecordBatch__Raw(). "); + Rf_error("Cannot call ipc___SerializeRecordBatch__Raw(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2792,7 +2792,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___ReadRecordBatch__InputStream__Schema(SEXP stream_sexp, SEXP schema_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___ReadRecordBatch__InputStream__Schema(). "); + Rf_error("Cannot call ipc___ReadRecordBatch__InputStream__Schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2808,7 +2808,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatch__from_arrays(SEXP schema_sxp_sexp, SEXP lst_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatch__from_arrays(). "); + Rf_error("Cannot call RecordBatch__from_arrays(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2823,7 +2823,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatchReader__schema(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__schema(). "); + Rf_error("Cannot call RecordBatchReader__schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2838,7 +2838,7 @@ END_RCPP } #else RcppExport SEXP _arrow_RecordBatchReader__ReadNext(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call RecordBatchReader__ReadNext(). "); + Rf_error("Cannot call RecordBatchReader__ReadNext(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2853,7 +2853,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__Open(SEXP stream_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__Open(). "); + Rf_error("Cannot call ipc___RecordBatchStreamReader__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2868,7 +2868,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchStreamReader__batches(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamReader__batches(). "); + Rf_error("Cannot call ipc___RecordBatchStreamReader__batches(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2883,7 +2883,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileReader__schema(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__schema(). "); + Rf_error("Cannot call ipc___RecordBatchFileReader__schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2898,7 +2898,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileReader__num_record_batches(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__num_record_batches(). "); + Rf_error("Cannot call ipc___RecordBatchFileReader__num_record_batches(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2914,7 +2914,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileReader__ReadRecordBatch(SEXP reader_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__ReadRecordBatch(). "); + Rf_error("Cannot call ipc___RecordBatchFileReader__ReadRecordBatch(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2929,7 +2929,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileReader__Open(SEXP file_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__Open(). "); + Rf_error("Cannot call ipc___RecordBatchFileReader__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2944,7 +2944,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__from_RecordBatchFileReader(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchFileReader(). "); + Rf_error("Cannot call Table__from_RecordBatchFileReader(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2959,7 +2959,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__from_RecordBatchStreamReader(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__from_RecordBatchStreamReader(). "); + Rf_error("Cannot call Table__from_RecordBatchStreamReader(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2974,7 +2974,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileReader__batches(SEXP reader_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileReader__batches(). "); + Rf_error("Cannot call ipc___RecordBatchFileReader__batches(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -2991,7 +2991,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteRecordBatch(SEXP batch_writer_sexp, SEXP batch_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteRecordBatch(). "); + Rf_error("Cannot call ipc___RecordBatchWriter__WriteRecordBatch(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3008,7 +3008,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchWriter__WriteTable(SEXP batch_writer_sexp, SEXP table_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__WriteTable(). "); + Rf_error("Cannot call ipc___RecordBatchWriter__WriteTable(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3024,7 +3024,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchWriter__Close(SEXP batch_writer_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchWriter__Close(). "); + Rf_error("Cannot call ipc___RecordBatchWriter__Close(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3040,7 +3040,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchFileWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchFileWriter__Open(). "); + Rf_error("Cannot call ipc___RecordBatchFileWriter__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3056,7 +3056,7 @@ END_RCPP } #else RcppExport SEXP _arrow_ipc___RecordBatchStreamWriter__Open(SEXP stream_sexp, SEXP schema_sexp){ - Rf_error("arrow C++ library not available. Cannot call ipc___RecordBatchStreamWriter__Open(). "); + Rf_error("Cannot call ipc___RecordBatchStreamWriter__Open(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3071,7 +3071,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__from_dataframe(SEXP tbl_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__from_dataframe(). "); + Rf_error("Cannot call Table__from_dataframe(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3086,7 +3086,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__num_columns(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__num_columns(). "); + Rf_error("Cannot call Table__num_columns(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3101,7 +3101,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__num_rows(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__num_rows(). "); + Rf_error("Cannot call Table__num_rows(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3116,7 +3116,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__schema(SEXP x_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__schema(). "); + Rf_error("Cannot call Table__schema(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3132,7 +3132,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__column(SEXP table_sexp, SEXP i_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__column(). "); + Rf_error("Cannot call Table__column(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3147,7 +3147,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__columns(SEXP table_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__columns(). "); + Rf_error("Cannot call Table__columns(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3163,7 +3163,7 @@ END_RCPP } #else RcppExport SEXP _arrow_Table__from_dots(SEXP lst_sexp, SEXP schema_sxp_sexp){ - Rf_error("arrow C++ library not available. Cannot call Table__from_dots(). "); + Rf_error("Cannot call Table__from_dots(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3177,7 +3177,7 @@ END_RCPP } #else RcppExport SEXP _arrow_GetCpuThreadPoolCapacity(){ - Rf_error("arrow C++ library not available. Cannot call GetCpuThreadPoolCapacity(). "); + Rf_error("Cannot call GetCpuThreadPoolCapacity(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif @@ -3193,7 +3193,7 @@ END_RCPP } #else RcppExport SEXP _arrow_SetCpuThreadPoolCapacity(SEXP threads_sexp){ - Rf_error("arrow C++ library not available. Cannot call SetCpuThreadPoolCapacity(). "); + Rf_error("Cannot call SetCpuThreadPoolCapacity(). Please use arrow::install_arrow() to install required runtime libraries. "); } #endif