You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by pa...@apache.org on 2023/07/17 16:55:49 UTC
[arrow-nanoarrow] 03/03: add release build
This is an automated email from the ASF dual-hosted git repository.
paleolimbot pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
commit f7a064aa21de33a9ed1ffba2d7a57a6e6cd4eac3
Author: Dewey Dunnington <de...@voltrondata.com>
AuthorDate: Mon Jul 17 13:55:26 2023 -0300
add release build
---
.nojekyll | 0
0.2.0/.buildinfo | 4 +
0.2.0/.doctrees/c.doctree | Bin 0 -> 1010668 bytes
0.2.0/.doctrees/cpp.doctree | Bin 0 -> 166422 bytes
0.2.0/.doctrees/environment.pickle | Bin 0 -> 2677214 bytes
0.2.0/.doctrees/getting-started.doctree | Bin 0 -> 64948 bytes
0.2.0/.doctrees/getting-started_generated.doctree | Bin 0 -> 61716 bytes
0.2.0/.doctrees/index.doctree | Bin 0 -> 17188 bytes
0.2.0/.doctrees/ipc.doctree | Bin 0 -> 234071 bytes
0.2.0/_sources/c.rst.txt | 78 +
0.2.0/_sources/cpp.rst.txt | 43 +
0.2.0/_sources/getting-started.rst.txt | 18 +
0.2.0/_sources/getting-started_generated.rst.txt | 540 +
0.2.0/_sources/index.rst.txt | 29 +
0.2.0/_sources/ipc.rst.txt | 33 +
0.2.0/_static/basic.css | 903 ++
0.2.0/_static/doctools.js | 156 +
0.2.0/_static/documentation_options.js | 14 +
0.2.0/_static/file.png | Bin 0 -> 286 bytes
0.2.0/_static/language_data.js | 199 +
0.2.0/_static/minus.png | Bin 0 -> 90 bytes
0.2.0/_static/plus.png | Bin 0 -> 90 bytes
0.2.0/_static/pygments.css | 152 +
0.2.0/_static/scripts/bootstrap.js | 3 +
0.2.0/_static/scripts/bootstrap.js.LICENSE.txt | 5 +
0.2.0/_static/scripts/bootstrap.js.map | 1 +
0.2.0/_static/scripts/pydata-sphinx-theme.js | 2 +
0.2.0/_static/scripts/pydata-sphinx-theme.js.map | 1 +
0.2.0/_static/searchtools.js | 566 +
0.2.0/_static/sphinx_highlight.js | 144 +
0.2.0/_static/styles/bootstrap.css | 6 +
0.2.0/_static/styles/pydata-sphinx-theme.css | 1 +
0.2.0/_static/styles/theme.css | 2 +
0.2.0/_static/vendor/fontawesome/6.1.2/LICENSE.txt | 165 +
.../vendor/fontawesome/6.1.2/css/all.min.css | 5 +
.../fontawesome/6.1.2/webfonts/fa-brands-400.ttf | Bin 0 -> 181264 bytes
.../fontawesome/6.1.2/webfonts/fa-brands-400.woff2 | Bin 0 -> 105112 bytes
.../fontawesome/6.1.2/webfonts/fa-regular-400.ttf | Bin 0 -> 60236 bytes
.../6.1.2/webfonts/fa-regular-400.woff2 | Bin 0 -> 24028 bytes
.../fontawesome/6.1.2/webfonts/fa-solid-900.ttf | Bin 0 -> 389948 bytes
.../fontawesome/6.1.2/webfonts/fa-solid-900.woff2 | Bin 0 -> 154840 bytes
.../6.1.2/webfonts/fa-v4compatibility.ttf | Bin 0 -> 10084 bytes
.../6.1.2/webfonts/fa-v4compatibility.woff2 | Bin 0 -> 4776 bytes
0.2.0/_static/webpack-macros.html | 30 +
0.2.0/c.html | 2428 +++++
0.2.0/cpp.html | 797 ++
0.2.0/genindex.html | 1192 ++
0.2.0/getting-started.html | 998 ++
0.2.0/getting-started_generated.html | 978 ++
0.2.0/index.html | 593 +
0.2.0/ipc.html | 914 ++
0.2.0/objects.inv | Bin 0 -> 16590 bytes
0.2.0/r/.nojekyll | 1 +
0.2.0/r/404.html | 90 +
0.2.0/r/LICENSE.html | 145 +
0.2.0/r/authors.html | 98 +
.../r/deps/bootstrap-5.2.2/bootstrap.bundle.min.js | 7 +
.../bootstrap-5.2.2/bootstrap.bundle.min.js.map | 1 +
0.2.0/r/deps/bootstrap-5.2.2/bootstrap.min.css | 6 +
0.2.0/r/deps/data-deps.txt | 4 +
0.2.0/r/deps/jquery-3.6.0/jquery-3.6.0.js | 10881 +++++++++++++++++++
0.2.0/r/deps/jquery-3.6.0/jquery-3.6.0.min.js | 2 +
0.2.0/r/deps/jquery-3.6.0/jquery-3.6.0.min.map | 1 +
0.2.0/r/index.html | 323 +
0.2.0/r/link.svg | 12 +
0.2.0/r/news/index.html | 68 +
0.2.0/r/pkgdown.js | 156 +
0.2.0/r/pkgdown.yml | 6 +
0.2.0/r/reference/Rplot001.png | Bin 0 -> 1011 bytes
0.2.0/r/reference/array_stream_set_finalizer.html | 126 +
0.2.0/r/reference/as_nanoarrow_array.html | 156 +
0.2.0/r/reference/as_nanoarrow_array_stream.html | 172 +
0.2.0/r/reference/as_nanoarrow_buffer.html | 114 +
0.2.0/r/reference/as_nanoarrow_schema.html | 152 +
0.2.0/r/reference/basic_array_stream.html | 117 +
0.2.0/r/reference/convert_array.html | 155 +
0.2.0/r/reference/convert_array_stream.html | 130 +
0.2.0/r/reference/index.html | 146 +
0.2.0/r/reference/infer_nanoarrow_ptype.html | 120 +
0.2.0/r/reference/na_type.html | 307 +
0.2.0/r/reference/nanoarrow-package.html | 85 +
0.2.0/r/reference/nanoarrow_array_init.html | 166 +
0.2.0/r/reference/nanoarrow_buffer_init.html | 117 +
0.2.0/r/reference/nanoarrow_pointer_is_valid.html | 182 +
0.2.0/r/reference/nanoarrow_version.html | 98 +
0.2.0/r/search.json | 1 +
0.2.0/r/sitemap.xml | 66 +
0.2.0/search.html | 433 +
0.2.0/searchindex.js | 1 +
index.html | 2 +
latest/index.html | 2 +
91 files changed, 25649 insertions(+)
diff --git a/.nojekyll b/.nojekyll
new file mode 100644
index 0000000..e69de29
diff --git a/0.2.0/.buildinfo b/0.2.0/.buildinfo
new file mode 100644
index 0000000..176d533
--- /dev/null
+++ b/0.2.0/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 6b0646ee36a69967d62dae64b2478944
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/0.2.0/.doctrees/c.doctree b/0.2.0/.doctrees/c.doctree
new file mode 100644
index 0000000..550146e
Binary files /dev/null and b/0.2.0/.doctrees/c.doctree differ
diff --git a/0.2.0/.doctrees/cpp.doctree b/0.2.0/.doctrees/cpp.doctree
new file mode 100644
index 0000000..a0f80c0
Binary files /dev/null and b/0.2.0/.doctrees/cpp.doctree differ
diff --git a/0.2.0/.doctrees/environment.pickle b/0.2.0/.doctrees/environment.pickle
new file mode 100644
index 0000000..7552665
Binary files /dev/null and b/0.2.0/.doctrees/environment.pickle differ
diff --git a/0.2.0/.doctrees/getting-started.doctree b/0.2.0/.doctrees/getting-started.doctree
new file mode 100644
index 0000000..2770500
Binary files /dev/null and b/0.2.0/.doctrees/getting-started.doctree differ
diff --git a/0.2.0/.doctrees/getting-started_generated.doctree b/0.2.0/.doctrees/getting-started_generated.doctree
new file mode 100644
index 0000000..28932c2
Binary files /dev/null and b/0.2.0/.doctrees/getting-started_generated.doctree differ
diff --git a/0.2.0/.doctrees/index.doctree b/0.2.0/.doctrees/index.doctree
new file mode 100644
index 0000000..0432da5
Binary files /dev/null and b/0.2.0/.doctrees/index.doctree differ
diff --git a/0.2.0/.doctrees/ipc.doctree b/0.2.0/.doctrees/ipc.doctree
new file mode 100644
index 0000000..c064e05
Binary files /dev/null and b/0.2.0/.doctrees/ipc.doctree differ
diff --git a/0.2.0/_sources/c.rst.txt b/0.2.0/_sources/c.rst.txt
new file mode 100644
index 0000000..352d0e9
--- /dev/null
+++ b/0.2.0/_sources/c.rst.txt
@@ -0,0 +1,78 @@
+.. 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.
+
+C API Reference
+==================
+
+.. doxygengroup:: nanoarrow
+
+Creating schemas
+------------------
+.. doxygengroup:: nanoarrow-schema
+ :members:
+
+Reading schemas
+------------------
+.. doxygengroup:: nanoarrow-schema-view
+ :members:
+
+Creating arrays
+------------------
+.. doxygengroup:: nanoarrow-array
+ :members:
+
+Reading arrays
+------------------
+.. doxygengroup:: nanoarrow-array-view
+ :members:
+
+Owning, growable buffers
+------------------------
+.. doxygengroup:: nanoarrow-buffer
+ :members:
+
+Bitmap utilities
+------------------
+.. doxygengroup:: nanoarrow-bitmap
+ :members:
+
+Create, read, and modify schema metadata
+----------------------------------------
+.. doxygengroup:: nanoarrow-metadata
+ :members:
+
+Memory management
+------------------
+.. doxygengroup:: nanoarrow-malloc
+ :members:
+
+Error handling
+------------------
+.. doxygengroup:: nanoarrow-errors
+ :members:
+
+Utility data structures
+-----------------------
+.. doxygengroup:: nanoarrow-utils
+ :members:
+
+Arrow C Data Interface
+----------------------
+
+.. doxygengroup:: nanoarrow-arrow-cdata
+ :members:
+ :undoc-members:
diff --git a/0.2.0/_sources/cpp.rst.txt b/0.2.0/_sources/cpp.rst.txt
new file mode 100644
index 0000000..615262f
--- /dev/null
+++ b/0.2.0/_sources/cpp.rst.txt
@@ -0,0 +1,43 @@
+.. 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.
+
+C++ API Reference
+==================
+
+.. doxygengroup:: nanoarrow_hpp
+
+Error handling
+--------------
+
+.. doxygengroup:: nanoarrow_hpp-errors
+ :members:
+
+Owning object wrappers
+----------------------
+.. doxygengroup:: nanoarrow_hpp-unique
+ :members:
+
+Array Stream utilities
+----------------------
+
+.. doxygengroup:: nanoarrow_hpp-array-stream
+ :members:
+
+Base classes and utilities
+--------------------------
+.. doxygengroup:: nanoarrow_hpp-unique_base
+ :members:
diff --git a/0.2.0/_sources/getting-started.rst.txt b/0.2.0/_sources/getting-started.rst.txt
new file mode 100644
index 0000000..18e9b39
--- /dev/null
+++ b/0.2.0/_sources/getting-started.rst.txt
@@ -0,0 +1,18 @@
+.. 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:: getting-started_generated.rst
diff --git a/0.2.0/_sources/getting-started_generated.rst.txt b/0.2.0/_sources/getting-started_generated.rst.txt
new file mode 100644
index 0000000..35d81e2
--- /dev/null
+++ b/0.2.0/_sources/getting-started_generated.rst.txt
@@ -0,0 +1,540 @@
+.. raw:: html
+
+ <!---
+ 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.
+ -->
+
+Getting started with nanoarrow
+==============================
+
+This tutorial provides a short example of writing a C++ library that
+exposes an Arrow-based API and uses nanoarrow to implement a simple text
+file reader/writer. In general, nanoarrow can help you write a library
+or application that:
+
+- exposes an Arrow-based API to read from a data source or format,
+- exposes an Arrow-based API to write to a data source or format,
+- exposes one or more compute functions that operates on and produces
+ data in the form of Arrow arrays, and/or
+- exposes an extension type implementation.
+
+Becauase Arrow has bindings in many languages, it means that you or
+others can easily bind or use your tool in higher-level runtimes like R,
+Java, C++, Python, Rust, Julia, Go, or Ruby, among others.
+
+The nanoarrow library is not the only way that an Arrow-based API can be
+implemented: Arrow C++, Rust, and Go are all excellent choices and can
+compile into static libraries that are C-linkable from other languages;
+however, existing Arrow implementations produce relatively large static
+libraries and can present complex build-time or run-time linking
+requirements depending on the implementation and features used. If the
+set of libraries you’re working with already provide the conveniences
+you require, nanoarrow may provide all the functionality you need.
+
+Now that we’ve talked about why you might want to build a library with
+nanoarrow…let’s build one!
+
+.. note::
+ This tutorial also goes over some of the basic structure of writing a C++ library.
+ If you already know how to do this, feel free to scroll to the code examples provided
+ below or take a look at the
+ `final example project <https://github.com/apache/arrow-nanoarrow/tree/main/examples/linesplitter>`__.
+The library
+-----------
+
+The library we’ll write in this tutorial is a simple text processing
+library that splits and reassembles lines of text. It will be able to:
+
+- Read text from a buffer into an ``ArrowArray`` as one element per
+ line, and
+- Write elements of an ``ArrowArray`` into a buffer, inserting line
+ breaks after every element.
+
+For the sake of argument, we’ll call it ``linesplitter``.
+
+The development environment
+---------------------------
+
+There are many excellent IDEs that can be used to develop C and C++
+libraries. For this tutorial, we will use
+`VSCode <https://code.visualstudio.com/>`__ and
+`CMake <https://cmake.org/>`__. You’ll need both installed to follow
+along: VSCode can be downloaded from the official site for most
+platforms; CMake is typically installed via your favourite package
+manager (e.g., ``brew install cmake``, ``apt-get install cmake``,
+``dnf install cmake``, etc.). You will also need a C and C++ compiler:
+on MacOS these can be installed using ``xcode-select --install``; on
+Linux you will need the packages that provide ``gcc``, ``g++``, and
+``make`` (e.g., ``apt-get install build-essential``); on Windows you
+will need to install `Visual
+Studio <https://visualstudio.microsoft.com/downloads/>`__ and CMake from
+the official download pages.
+
+Once you have VSCode installed, ensure you have the **CMake Tools** and
+**C/C++** extensions installed. Once your environment is set up, create
+a folder called ``linesplitter`` and open it using **File -> Open
+Folder**.
+
+The interface
+-------------
+
+We’ll expose the interface to our library as a header called
+``linesplitter.h``. To ensure the definitions are only included once in
+any given source file, we’ll add the following line at the top:
+
+.. code:: cpp
+
+ #pragma once
+
+Then, we need the `Arrow C Data
+interface <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>`__
+itself, since it provides the type definitions that are recognized by
+other Arrow implementations on which our API will be built. It’s
+designed to be copy and pasted in this way - there’s no need to put it
+in another file include something from another project.
+
+.. code:: cpp
+
+ #include <stdint.h>
+
+ #ifndef ARROW_C_DATA_INTERFACE
+ #define ARROW_C_DATA_INTERFACE
+
+ #define ARROW_FLAG_DICTIONARY_ORDERED 1
+ #define ARROW_FLAG_NULLABLE 2
+ #define ARROW_FLAG_MAP_KEYS_SORTED 4
+
+ struct ArrowSchema {
+ // Array type description
+ const char* format;
+ const char* name;
+ const char* metadata;
+ int64_t flags;
+ int64_t n_children;
+ struct ArrowSchema** children;
+ struct ArrowSchema* dictionary;
+
+ // Release callback
+ void (*release)(struct ArrowSchema*);
+ // Opaque producer-specific data
+ void* private_data;
+ };
+
+ struct ArrowArray {
+ // Array data description
+ int64_t length;
+ int64_t null_count;
+ int64_t offset;
+ int64_t n_buffers;
+ int64_t n_children;
+ const void** buffers;
+ struct ArrowArray** children;
+ struct ArrowArray* dictionary;
+
+ // Release callback
+ void (*release)(struct ArrowArray*);
+ // Opaque producer-specific data
+ void* private_data;
+ };
+
+ #endif // ARROW_C_DATA_INTERFACE
+
+Next, we’ll provide definitions for the functions we’ll implement below:
+
+.. code:: c
+
+ // Builds an ArrowArray of type string that will contain one element for each line
+ // in src and places it into out.
+ //
+ // On success, returns {0, ""}; on error, returns {<errno code>, <error message>}
+ std::pair<int, std::string> linesplitter_read(const std::string& src,
+ struct ArrowArray* out);
+
+ // Concatenates all elements of a string ArrowArray inserting a newline between
+ // elements.
+ //
+ // On success, returns {0, <result>}; on error, returns {<errno code>, <error message>}
+ std::pair<int, std::string> linesplitter_write(struct ArrowArray* input);
+
+.. note::
+ You may notice that we don't include or mention nanoarrow in any way in the header
+ that is exposed to users. Because nanoarrow is designed to be vendored and is not
+ distributed as a system library, it is not safe for users of your library to
+ ``#include "nanoarrow.h"`` because it might conflict with another library that does
+ the same (with possibly a different version of nanoarrow).
+Arrow C data/nanoarrow interface basics
+---------------------------------------
+
+Now that we’ve seen the functions we need to implement and the Arrow
+types exposed in the C data interface, let’s unpack a few basics about
+using the Arrow C data interface and a few conventions used in the
+nanoarrow implementation.
+
+First, let’s discuss the ``ArrowSchema`` and the ``ArrowArray``. You can
+think of an ``ArrowSchema`` as an expression of a data type, whereas an
+``ArrowArray`` is the data itself. These structures accomodate nested
+types: columns are encoded in the ``children`` member of each. You
+always need to know the data type of an ``ArrowArray`` before accessing
+its contents. In our case we only operate on arrays of one type
+(“string”) and document that in our interface; for functions that
+operate on more than one type of array you will need to accept an
+``ArrowSchema`` and inspect it (e.g., using nanoarrow’s helper
+functions).
+
+Second, let’s discuss error handling. You may have noticed in the
+function definitions above that we return ``int``, which is an
+errno-compatible error code or ``0`` to indicate success. Functions in
+nanoarrow that need to communicate more detailed error information
+accept an ``ArrowError*`` argument (which can be ``NULL`` if the caller
+does care about the extra information). Any nanoarrow function that
+might fail communicates errors in this way. To avoid verbose code like
+the following:
+
+.. code:: c
+
+ int init_string_non_null(struct ArrowSchema* schema) {
+ int code = ArrowSchemaInitFromType(&schema, NANOARROW_TYPE_STRING);
+ if (code != NANOARROW_OK) {
+ return code;
+ }
+
+ schema->flags &= ~ARROW_FLAG_NULLABLE;
+ return NANOARROW_OK;
+ }
+
+…you can use the ``NANOARROW_RETURN_NOT_OK()`` macro:
+
+.. code:: c
+
+ int init_string_non_null(struct ArrowSchema* schema) {
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(&schema, NANOARROW_TYPE_STRING));
+ schema->flags &= ~ARROW_FLAG_NULLABLE;
+ return NANOARROW_OK;
+ }
+
+This works as long as your internal functions that use nanoarrow also
+return ``int`` and/or an ``ArrowError*`` argument. This usually means
+that there is an outer function that presents a more idiomatic interface
+(e.g., returning ``std::optional<>`` or throwing an exception) and an
+inner function that uses nanoarrow-style error handling. Embracing
+``NANOARROW_RETURN_NOT_OK()`` is key to hapiness when using the
+nanoarrow library.
+
+Third, let’s discuss memory management. Because nanoarrow is implemented
+in C and provides a C interface, the library by default uses C-style
+memory management (i.e., if you allocate it, you clean it up). This is
+unnecessary when you have C++ at your disposal, so nanoarrow also
+provides a C++ header (``nanoarrow.hpp``) with
+``std::unique_ptr<>``-like wrappers around anything that requires
+explicit clean up. Whereas in C you might have to write code like this:
+
+.. code:: c
+
+ struct ArrowSchema schema;
+ struct ArrowArray array;
+
+ // Ok: if this returns, array was not initialized
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(&schema, NANOARROW_TYPE_STRING));
+
+ // Verbose: if this fails, we need to release schema before returning
+ // or it will leak.
+ int code = ArrowArrayInitFromSchema(&array, &schema, NULL);
+ if (code != NANOARROW_OK) {
+ schema.release(&schema);
+ return code;
+ }
+
+…using the ``nanoarrow.hpp`` types we can do:
+
+.. code:: cpp
+
+ nanoarrow::UniqueSchema schema;
+ nanoarrow::UniqueArray array;
+
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitFromType(schema.get(), NANOARROW_TYPE_STRING));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayInitFromSchema(array.get(), schema.get(), NULL));
+
+Building the library
+--------------------
+
+Our library implementation will live in ``linesplitter.cc``. Before
+writing the actual implementations, let’s add just enough to our project
+that we can build it using VSCode’s C/C++/CMake integration:
+
+.. code:: cpp
+
+ #include <cerrno>
+ #include <cstdint>
+ #include <sstream>
+ #include <string>
+ #include <utility>
+
+ #include "nanoarrow/nanoarrow.hpp"
+
+ #include "linesplitter.h"
+
+ std::pair<int, std::string> linesplitter_read(const std::string& src,
+ struct ArrowArray* out) {
+ return {ENOTSUP, ""};
+ }
+
+ std::pair<int, std::string> linesplitter_write(struct ArrowArray* input) {
+ return {ENOTSUP, ""};
+ }
+
+We also need a ``CMakeLists.txt`` file that tells CMake and VSCode what
+to build. CMake has a lot of options and can scale to coordinate very
+large projects; however we only need a few lines to leverage VSCode’s
+integration.
+
+.. code:: cmake
+
+ project(linesplitter)
+
+ set(CMAKE_CXX_STANDARD 11)
+
+ include(FetchContent)
+
+ FetchContent_Declare(
+ nanoarrow
+ URL https://github.com/apache/arrow-nanoarrow/releases/download/apache-arrow-nanoarrow-0.1.0/apache-arrow-nanoarrow-0.1.0.tar.gz
+ URL_HASH SHA512=dc62480b986ee76aaad8e38c6fbc602f8cef2cc35a5f5ede7da2a93b4db2b63839bdca3eefe8a44ae1cb6895a2fd3f090e3f6ea1020cf93cfe86437304dfee17)
+ FetchContent_MakeAvailable(nanoarrow)
+
+ add_library(linesplitter linesplitter.cc)
+ target_link_libraries(linesplitter PRIVATE nanoarrow)
+
+After saving ``CMakeLists.txt``, you may have to close and re-open the
+``linesplitter`` directory in VSCode to activate the CMake integration.
+From the command pallete (i.e., Control/Command-Shift-P), choose
+**CMake: Build**. If all went well, you should see a few lines of output
+indicating progress towards building and linking ``linesplitter``.
+
+.. note::
+ Depending on your version of CMake you might also see a few warnings. This CMakeLists.txt
+ is intentionally minimal and as such does not attempt to silence them.
+.. note::
+ If you're not using VSCode, you can accomplish the equivalent task in in a terminal
+ with ``mkdir build && cd build && cmake .. && cmake --build .``.
+Building an ArrowArray
+----------------------
+
+The input for our ``linesplitter_read()`` function in an
+``std::string``, which we’ll iterate over and add each detected line as
+its own element. First, some core logic to detect the number of
+characters until the next ``\n`` or end-of-string.
+
+.. code:: cpp
+
+ static int64_t find_newline(const ArrowStringView& src) {
+ for (int64_t i = 0; i < src.size_bytes; i++) {
+ if (src.data[i] == '\n') {
+ return i;
+ }
+ }
+
+ return src.size_bytes;
+ }
+
+The next function we’ll define is an internal function that uses
+nanoarrow-style error handling. This uses the ``ArrowArrayAppend*()``
+family of functions provided by nanoarrow to build the array:
+
+.. code:: cpp
+
+ static int linesplitter_read_internal(const std::string& src, ArrowArray* out,
+ ArrowError* error) {
+ nanoarrow::UniqueArray tmp;
+ NANOARROW_RETURN_NOT_OK(ArrowArrayInitFromType(tmp.get(), NANOARROW_TYPE_STRING));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayStartAppending(tmp.get()));
+
+ ArrowStringView src_view = {src.data(), static_cast<int64_t>(src.size())};
+ ArrowStringView line_view;
+ int64_t next_newline = -1;
+ while ((next_newline = find_newline(src_view)) >= 0) {
+ line_view = {src_view.data, next_newline};
+ NANOARROW_RETURN_NOT_OK(ArrowArrayAppendString(tmp.get(), line_view));
+ src_view.data += next_newline + 1;
+ src_view.size_bytes -= next_newline + 1;
+ }
+
+ NANOARROW_RETURN_NOT_OK(ArrowArrayFinishBuildingDefault(tmp.get(), error));
+
+ ArrowArrayMove(tmp.get(), out);
+ return NANOARROW_OK;
+ }
+
+Finally, we define a wrapper that corresponds to the outer function
+definition.
+
+.. code:: cpp
+
+ std::pair<int, std::string> linesplitter_read(const std::string& src, ArrowArray* out) {
+ ArrowError error;
+ int code = linesplitter_read_internal(src, out, &error);
+ if (code != NANOARROW_OK) {
+ return {code, std::string(ArrowErrorMessage(&error))};
+ } else {
+ return {NANOARROW_OK, ""};
+ }
+ }
+
+Reading an ArrowArray
+---------------------
+
+The input for our ``linesplitter_write()`` function is an
+``ArrowArray*`` like the one we create in ``linesplitter_read()``. Just
+as nanoarrow provides helpers to build arrays, it also provides helpers
+to read them via the ``ArrowArrayView*()`` family of functions. Again,
+we first define an internal function that uses nanoarrow-style error
+handling:
+
+.. code:: cpp
+
+ static int linesplitter_write_internal(ArrowArray* input, std::stringstream& out,
+ ArrowError* error) {
+ nanoarrow::UniqueArrayView input_view;
+ ArrowArrayViewInitFromType(input_view.get(), NANOARROW_TYPE_STRING);
+ NANOARROW_RETURN_NOT_OK(ArrowArrayViewSetArray(input_view.get(), input, error));
+
+ ArrowStringView item;
+ for (int64_t i = 0; i < input->length; i++) {
+ if (ArrowArrayViewIsNull(input_view.get(), i)) {
+ out << "\n";
+ } else {
+ item = ArrowArrayViewGetStringUnsafe(input_view.get(), i);
+ out << std::string(item.data, item.size_bytes) << "\n";
+ }
+ }
+
+ return NANOARROW_OK;
+ }
+
+Then, provide an outer wrapper that corresponds to the outer function
+definition.
+
+.. code:: cpp
+
+ std::pair<int, std::string> linesplitter_write(ArrowArray* input) {
+ std::stringstream out;
+ ArrowError error;
+ int code = linesplitter_write_internal(input, out, &error);
+ if (code != NANOARROW_OK) {
+ return {code, std::string(ArrowErrorMessage(&error))};
+ } else {
+ return {NANOARROW_OK, out.str()};
+ }
+ }
+
+Testing
+-------
+
+We have an implementation, but does it work? Unlike higher-level
+runtimes like R and Python, we can’t just open a prompt and type some
+code to find out. For C and C++ libraries, the
+`googletest <https://google.github.io/googletest/quickstart-cmake.html>`__
+framework provides a quick and easy way to do this that scales nicely as
+the complexity of your project grows.
+
+First, we’ll add a stub test and some CMake to get going. In
+``linesplitter_test.cc``, add the following:
+
+.. code:: cpp
+
+ #include <gtest/gtest.h>
+
+ #include "nanoarrow/nanoarrow.hpp"
+
+ #include "linesplitter.h"
+
+ TEST(Linesplitter, LinesplitterRoundtrip) {
+ EXPECT_EQ(4, 4);
+ }
+
+Then, add the following to your ``CMakeLists.txt``:
+
+.. code:: cmake
+
+ FetchContent_Declare(
+ googletest
+ URL https://github.com/google/googletest/archive/refs/tags/v1.13.0.zip
+ )
+ FetchContent_MakeAvailable(googletest)
+
+ enable_testing()
+
+ add_executable(linesplitter_test linesplitter_test.cc)
+ target_link_libraries(linesplitter_test linesplitter GTest::gtest_main)
+
+ include(GoogleTest)
+ gtest_discover_tests(linesplitter_test)
+
+After you’re done, build the project again using the **CMake: Build**
+command from the command palette. If all goes well, choose **Test: Run
+All Tests** from the command pallete to run them! You should see some
+output indiciating that tests ran successfully, or you can use VSCode’s
+“Testing” panel to visually inspect which tests passed.
+
+.. note::
+ If you're not using VSCode, you can accomplish the equivalent task in in a terminal
+ with ``cd build && ctest .``.
+Now we’re ready to fill in the test! Our two functions happen to round
+trip, so a useful first test might be to check.
+
+.. code:: cpp
+
+ TEST(Linesplitter, LinesplitterRoundtrip) {
+ nanoarrow::UniqueArray out;
+ auto result = linesplitter_read("line1\nline2\nline3", out.get());
+ ASSERT_EQ(result.first, 0);
+ ASSERT_EQ(result.second, "");
+
+ ASSERT_EQ(out->length, 3);
+
+ nanoarrow::UniqueArrayView out_view;
+ ArrowArrayViewInitFromType(out_view.get(), NANOARROW_TYPE_STRING);
+ ASSERT_EQ(ArrowArrayViewSetArray(out_view.get(), out.get(), nullptr), 0);
+ ArrowStringView item;
+
+ item = ArrowArrayViewGetStringUnsafe(out_view.get(), 0);
+ ASSERT_EQ(std::string(item.data, item.size_bytes), "line1");
+
+ item = ArrowArrayViewGetStringUnsafe(out_view.get(), 1);
+ ASSERT_EQ(std::string(item.data, item.size_bytes), "line2");
+
+ item = ArrowArrayViewGetStringUnsafe(out_view.get(), 2);
+ ASSERT_EQ(std::string(item.data, item.size_bytes), "line3");
+
+
+ auto result2 = linesplitter_write(out.get());
+ ASSERT_EQ(result2.first, 0);
+ ASSERT_EQ(result2.second, "line1\nline2\nline3\n");
+ }
+
+Writing tests in this way also opens up a relatively straightforward
+debug path via the **CMake: Set Debug target** and **CMake: Debug**
+commands. If the first thing that happens when you write run your test
+is a crash, running the tests with the debugger turned on will
+automatically pause at the line of code that caused the crash. For more
+fine-tuned debugging, you can set breakpoints and step through code.
+
+Summary
+-------
+
+This tutorial covered the basics of writing and testing a C++ library
+exposing an Arrow-based API implemented using the nanoarrow C library.
diff --git a/0.2.0/_sources/index.rst.txt b/0.2.0/_sources/index.rst.txt
new file mode 100644
index 0000000..fa31569
--- /dev/null
+++ b/0.2.0/_sources/index.rst.txt
@@ -0,0 +1,29 @@
+.. 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:: README_generated.rst
+
+Contents
+--------
+
+.. toctree::
+ :maxdepth: 2
+
+ Getting Started <getting-started>
+ C API Reference <c>
+ C++ API Reference <cpp>
+ IPC Extension Reference <ipc>
diff --git a/0.2.0/_sources/ipc.rst.txt b/0.2.0/_sources/ipc.rst.txt
new file mode 100644
index 0000000..fb009c1
--- /dev/null
+++ b/0.2.0/_sources/ipc.rst.txt
@@ -0,0 +1,33 @@
+.. 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.
+
+IPC Extension Reference
+=======================
+
+C API
+------------------------
+
+.. doxygengroup:: nanoarrow_ipc
+ :project: nanoarrow_ipc
+ :members:
+
+C++ Helpers
+------------------------
+
+.. doxygengroup:: nanoarrow_ipc_hpp-unique
+ :project: nanoarrow_ipc
+ :members:
diff --git a/0.2.0/_static/basic.css b/0.2.0/_static/basic.css
new file mode 100644
index 0000000..6157296
--- /dev/null
+++ b/0.2.0/_static/basic.css
@@ -0,0 +1,903 @@
+/*
+ * basic.css
+ * ~~~~~~~~~
+ *
+ * Sphinx stylesheet -- basic theme.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/* -- main layout ----------------------------------------------------------- */
+
+div.clearer {
+ clear: both;
+}
+
+div.section::after {
+ display: block;
+ content: '';
+ clear: left;
+}
+
+/* -- relbar ---------------------------------------------------------------- */
+
+div.related {
+ width: 100%;
+ font-size: 90%;
+}
+
+div.related h3 {
+ display: none;
+}
+
+div.related ul {
+ margin: 0;
+ padding: 0 0 0 10px;
+ list-style: none;
+}
+
+div.related li {
+ display: inline;
+}
+
+div.related li.right {
+ float: right;
+ margin-right: 5px;
+}
+
+/* -- sidebar --------------------------------------------------------------- */
+
+div.sphinxsidebarwrapper {
+ padding: 10px 5px 0 10px;
+}
+
+div.sphinxsidebar {
+ float: left;
+ width: 270px;
+ margin-left: -100%;
+ font-size: 90%;
+ word-wrap: break-word;
+ overflow-wrap : break-word;
+}
+
+div.sphinxsidebar ul {
+ list-style: none;
+}
+
+div.sphinxsidebar ul ul,
+div.sphinxsidebar ul.want-points {
+ margin-left: 20px;
+ list-style: square;
+}
+
+div.sphinxsidebar ul ul {
+ margin-top: 0;
+ margin-bottom: 0;
+}
+
+div.sphinxsidebar form {
+ margin-top: 10px;
+}
+
+div.sphinxsidebar input {
+ border: 1px solid #98dbcc;
+ font-family: sans-serif;
+ font-size: 1em;
+}
+
+div.sphinxsidebar #searchbox form.search {
+ overflow: hidden;
+}
+
+div.sphinxsidebar #searchbox input[type="text"] {
+ float: left;
+ width: 80%;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+div.sphinxsidebar #searchbox input[type="submit"] {
+ float: left;
+ width: 20%;
+ border-left: none;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+
+img {
+ border: 0;
+ max-width: 100%;
+}
+
+/* -- search page ----------------------------------------------------------- */
+
+ul.search {
+ margin: 10px 0 0 20px;
+ padding: 0;
+}
+
+ul.search li {
+ padding: 5px 0 5px 20px;
+ background-image: url(file.png);
+ background-repeat: no-repeat;
+ background-position: 0 7px;
+}
+
+ul.search li a {
+ font-weight: bold;
+}
+
+ul.search li p.context {
+ color: #888;
+ margin: 2px 0 0 30px;
+ text-align: left;
+}
+
+ul.keywordmatches li.goodmatch a {
+ font-weight: bold;
+}
+
+/* -- index page ------------------------------------------------------------ */
+
+table.contentstable {
+ width: 90%;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table.contentstable p.biglink {
+ line-height: 150%;
+}
+
+a.biglink {
+ font-size: 1.3em;
+}
+
+span.linkdescr {
+ font-style: italic;
+ padding-top: 5px;
+ font-size: 90%;
+}
+
+/* -- general index --------------------------------------------------------- */
+
+table.indextable {
+ width: 100%;
+}
+
+table.indextable td {
+ text-align: left;
+ vertical-align: top;
+}
+
+table.indextable ul {
+ margin-top: 0;
+ margin-bottom: 0;
+ list-style-type: none;
+}
+
+table.indextable > tbody > tr > td > ul {
+ padding-left: 0em;
+}
+
+table.indextable tr.pcap {
+ height: 10px;
+}
+
+table.indextable tr.cap {
+ margin-top: 10px;
+ background-color: #f2f2f2;
+}
+
+img.toggler {
+ margin-right: 3px;
+ margin-top: 3px;
+ cursor: pointer;
+}
+
+div.modindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+div.genindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+/* -- domain module index --------------------------------------------------- */
+
+table.modindextable td {
+ padding: 2px;
+ border-collapse: collapse;
+}
+
+/* -- general body styles --------------------------------------------------- */
+
+div.body {
+ min-width: 360px;
+ max-width: 800px;
+}
+
+div.body p, div.body dd, div.body li, div.body blockquote {
+ -moz-hyphens: auto;
+ -ms-hyphens: auto;
+ -webkit-hyphens: auto;
+ hyphens: auto;
+}
+
+a.headerlink {
+ visibility: hidden;
+}
+
+h1:hover > a.headerlink,
+h2:hover > a.headerlink,
+h3:hover > a.headerlink,
+h4:hover > a.headerlink,
+h5:hover > a.headerlink,
+h6:hover > a.headerlink,
+dt:hover > a.headerlink,
+caption:hover > a.headerlink,
+p.caption:hover > a.headerlink,
+div.code-block-caption:hover > a.headerlink {
+ visibility: visible;
+}
+
+div.body p.caption {
+ text-align: inherit;
+}
+
+div.body td {
+ text-align: left;
+}
+
+.first {
+ margin-top: 0 !important;
+}
+
+p.rubric {
+ margin-top: 30px;
+ font-weight: bold;
+}
+
+img.align-left, figure.align-left, .figure.align-left, object.align-left {
+ clear: left;
+ float: left;
+ margin-right: 1em;
+}
+
+img.align-right, figure.align-right, .figure.align-right, object.align-right {
+ clear: right;
+ float: right;
+ margin-left: 1em;
+}
+
+img.align-center, figure.align-center, .figure.align-center, object.align-center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+img.align-default, figure.align-default, .figure.align-default {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+.align-left {
+ text-align: left;
+}
+
+.align-center {
+ text-align: center;
+}
+
+.align-default {
+ text-align: center;
+}
+
+.align-right {
+ text-align: right;
+}
+
+/* -- sidebars -------------------------------------------------------------- */
+
+div.sidebar,
+aside.sidebar {
+ margin: 0 0 0.5em 1em;
+ border: 1px solid #ddb;
+ padding: 7px;
+ background-color: #ffe;
+ width: 40%;
+ float: right;
+ clear: right;
+ overflow-x: auto;
+}
+
+p.sidebar-title {
+ font-weight: bold;
+}
+
+nav.contents,
+aside.topic,
+div.admonition, div.topic, blockquote {
+ clear: left;
+}
+
+/* -- topics ---------------------------------------------------------------- */
+
+nav.contents,
+aside.topic,
+div.topic {
+ border: 1px solid #ccc;
+ padding: 7px;
+ margin: 10px 0 10px 0;
+}
+
+p.topic-title {
+ font-size: 1.1em;
+ font-weight: bold;
+ margin-top: 10px;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ padding: 7px;
+}
+
+div.admonition dt {
+ font-weight: bold;
+}
+
+p.admonition-title {
+ margin: 0px 10px 5px 0px;
+ font-weight: bold;
+}
+
+div.body p.centered {
+ text-align: center;
+ margin-top: 25px;
+}
+
+/* -- content of sidebars/topics/admonitions -------------------------------- */
+
+div.sidebar > :last-child,
+aside.sidebar > :last-child,
+nav.contents > :last-child,
+aside.topic > :last-child,
+div.topic > :last-child,
+div.admonition > :last-child {
+ margin-bottom: 0;
+}
+
+div.sidebar::after,
+aside.sidebar::after,
+nav.contents::after,
+aside.topic::after,
+div.topic::after,
+div.admonition::after,
+blockquote::after {
+ display: block;
+ content: '';
+ clear: both;
+}
+
+/* -- tables ---------------------------------------------------------------- */
+
+table.docutils {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ border: 0;
+ border-collapse: collapse;
+}
+
+table.align-center {
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table.align-default {
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table caption span.caption-number {
+ font-style: italic;
+}
+
+table caption span.caption-text {
+}
+
+table.docutils td, table.docutils th {
+ padding: 1px 8px 1px 5px;
+ border-top: 0;
+ border-left: 0;
+ border-right: 0;
+ border-bottom: 1px solid #aaa;
+}
+
+th {
+ text-align: left;
+ padding-right: 5px;
+}
+
+table.citation {
+ border-left: solid 1px gray;
+ margin-left: 1px;
+}
+
+table.citation td {
+ border-bottom: none;
+}
+
+th > :first-child,
+td > :first-child {
+ margin-top: 0px;
+}
+
+th > :last-child,
+td > :last-child {
+ margin-bottom: 0px;
+}
+
+/* -- figures --------------------------------------------------------------- */
+
+div.figure, figure {
+ margin: 0.5em;
+ padding: 0.5em;
+}
+
+div.figure p.caption, figcaption {
+ padding: 0.3em;
+}
+
+div.figure p.caption span.caption-number,
+figcaption span.caption-number {
+ font-style: italic;
+}
+
+div.figure p.caption span.caption-text,
+figcaption span.caption-text {
+}
+
+/* -- field list styles ----------------------------------------------------- */
+
+table.field-list td, table.field-list th {
+ border: 0 !important;
+}
+
+.field-list ul {
+ margin: 0;
+ padding-left: 1em;
+}
+
+.field-list p {
+ margin: 0;
+}
+
+.field-name {
+ -moz-hyphens: manual;
+ -ms-hyphens: manual;
+ -webkit-hyphens: manual;
+ hyphens: manual;
+}
+
+/* -- hlist styles ---------------------------------------------------------- */
+
+table.hlist {
+ margin: 1em 0;
+}
+
+table.hlist td {
+ vertical-align: top;
+}
+
+/* -- object description styles --------------------------------------------- */
+
+.sig {
+ font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+}
+
+.sig-name, code.descname {
+ background-color: transparent;
+ font-weight: bold;
+}
+
+.sig-name {
+ font-size: 1.1em;
+}
+
+code.descname {
+ font-size: 1.2em;
+}
+
+.sig-prename, code.descclassname {
+ background-color: transparent;
+}
+
+.optional {
+ font-size: 1.3em;
+}
+
+.sig-paren {
+ font-size: larger;
+}
+
+.sig-param.n {
+ font-style: italic;
+}
+
+/* C++ specific styling */
+
+.sig-inline.c-texpr,
+.sig-inline.cpp-texpr {
+ font-family: unset;
+}
+
+.sig.c .k, .sig.c .kt,
+.sig.cpp .k, .sig.cpp .kt {
+ color: #0033B3;
+}
+
+.sig.c .m,
+.sig.cpp .m {
+ color: #1750EB;
+}
+
+.sig.c .s, .sig.c .sc,
+.sig.cpp .s, .sig.cpp .sc {
+ color: #067D17;
+}
+
+
+/* -- other body styles ----------------------------------------------------- */
+
+ol.arabic {
+ list-style: decimal;
+}
+
+ol.loweralpha {
+ list-style: lower-alpha;
+}
+
+ol.upperalpha {
+ list-style: upper-alpha;
+}
+
+ol.lowerroman {
+ list-style: lower-roman;
+}
+
+ol.upperroman {
+ list-style: upper-roman;
+}
+
+:not(li) > ol > li:first-child > :first-child,
+:not(li) > ul > li:first-child > :first-child {
+ margin-top: 0px;
+}
+
+:not(li) > ol > li:last-child > :last-child,
+:not(li) > ul > li:last-child > :last-child {
+ margin-bottom: 0px;
+}
+
+ol.simple ol p,
+ol.simple ul p,
+ul.simple ol p,
+ul.simple ul p {
+ margin-top: 0;
+}
+
+ol.simple > li:not(:first-child) > p,
+ul.simple > li:not(:first-child) > p {
+ margin-top: 0;
+}
+
+ol.simple p,
+ul.simple p {
+ margin-bottom: 0;
+}
+
+aside.footnote > span,
+div.citation > span {
+ float: left;
+}
+aside.footnote > span:last-of-type,
+div.citation > span:last-of-type {
+ padding-right: 0.5em;
+}
+aside.footnote > p {
+ margin-left: 2em;
+}
+div.citation > p {
+ margin-left: 4em;
+}
+aside.footnote > p:last-of-type,
+div.citation > p:last-of-type {
+ margin-bottom: 0em;
+}
+aside.footnote > p:last-of-type:after,
+div.citation > p:last-of-type:after {
+ content: "";
+ clear: both;
+}
+
+dl.field-list {
+ display: grid;
+ grid-template-columns: fit-content(30%) auto;
+}
+
+dl.field-list > dt {
+ font-weight: bold;
+ word-break: break-word;
+ padding-left: 0.5em;
+ padding-right: 5px;
+}
+
+dl.field-list > dd {
+ padding-left: 0.5em;
+ margin-top: 0em;
+ margin-left: 0em;
+ margin-bottom: 0em;
+}
+
+dl {
+ margin-bottom: 15px;
+}
+
+dd > :first-child {
+ margin-top: 0px;
+}
+
+dd ul, dd table {
+ margin-bottom: 10px;
+}
+
+dd {
+ margin-top: 3px;
+ margin-bottom: 10px;
+ margin-left: 30px;
+}
+
+dl > dd:last-child,
+dl > dd:last-child > :last-child {
+ margin-bottom: 0;
+}
+
+dt:target, span.highlighted {
+ background-color: #fbe54e;
+}
+
+rect.highlighted {
+ fill: #fbe54e;
+}
+
+dl.glossary dt {
+ font-weight: bold;
+ font-size: 1.1em;
+}
+
+.versionmodified {
+ font-style: italic;
+}
+
+.system-message {
+ background-color: #fda;
+ padding: 5px;
+ border: 3px solid red;
+}
+
+.footnote:target {
+ background-color: #ffa;
+}
+
+.line-block {
+ display: block;
+ margin-top: 1em;
+ margin-bottom: 1em;
+}
+
+.line-block .line-block {
+ margin-top: 0;
+ margin-bottom: 0;
+ margin-left: 1.5em;
+}
+
+.guilabel, .menuselection {
+ font-family: sans-serif;
+}
+
+.accelerator {
+ text-decoration: underline;
+}
+
+.classifier {
+ font-style: oblique;
+}
+
+.classifier:before {
+ font-style: normal;
+ margin: 0 0.5em;
+ content: ":";
+ display: inline-block;
+}
+
+abbr, acronym {
+ border-bottom: dotted 1px;
+ cursor: help;
+}
+
+/* -- code displays --------------------------------------------------------- */
+
+pre {
+ overflow: auto;
+ overflow-y: hidden; /* fixes display issues on Chrome browsers */
+}
+
+pre, div[class*="highlight-"] {
+ clear: both;
+}
+
+span.pre {
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ -webkit-hyphens: none;
+ hyphens: none;
+ white-space: nowrap;
+}
+
+div[class*="highlight-"] {
+ margin: 1em 0;
+}
+
+td.linenos pre {
+ border: 0;
+ background-color: transparent;
+ color: #aaa;
+}
+
+table.highlighttable {
+ display: block;
+}
+
+table.highlighttable tbody {
+ display: block;
+}
+
+table.highlighttable tr {
+ display: flex;
+}
+
+table.highlighttable td {
+ margin: 0;
+ padding: 0;
+}
+
+table.highlighttable td.linenos {
+ padding-right: 0.5em;
+}
+
+table.highlighttable td.code {
+ flex: 1;
+ overflow: hidden;
+}
+
+.highlight .hll {
+ display: block;
+}
+
+div.highlight pre,
+table.highlighttable pre {
+ margin: 0;
+}
+
+div.code-block-caption + div {
+ margin-top: 0;
+}
+
+div.code-block-caption {
+ margin-top: 1em;
+ padding: 2px 5px;
+ font-size: small;
+}
+
+div.code-block-caption code {
+ background-color: transparent;
+}
+
+table.highlighttable td.linenos,
+span.linenos,
+div.highlight span.gp { /* gp: Generic.Prompt */
+ user-select: none;
+ -webkit-user-select: text; /* Safari fallback only */
+ -webkit-user-select: none; /* Chrome/Safari */
+ -moz-user-select: none; /* Firefox */
+ -ms-user-select: none; /* IE10+ */
+}
+
+div.code-block-caption span.caption-number {
+ padding: 0.1em 0.3em;
+ font-style: italic;
+}
+
+div.code-block-caption span.caption-text {
+}
+
+div.literal-block-wrapper {
+ margin: 1em 0;
+}
+
+code.xref, a code {
+ background-color: transparent;
+ font-weight: bold;
+}
+
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ background-color: transparent;
+}
+
+.viewcode-link {
+ float: right;
+}
+
+.viewcode-back {
+ float: right;
+ font-family: sans-serif;
+}
+
+div.viewcode-block:target {
+ margin: -1px -10px;
+ padding: 0 10px;
+}
+
+/* -- math display ---------------------------------------------------------- */
+
+img.math {
+ vertical-align: middle;
+}
+
+div.body div.math p {
+ text-align: center;
+}
+
+span.eqno {
+ float: right;
+}
+
+span.eqno a.headerlink {
+ position: absolute;
+ z-index: 1;
+}
+
+div.math:hover a.headerlink {
+ visibility: visible;
+}
+
+/* -- printout stylesheet --------------------------------------------------- */
+
+@media print {
+ div.document,
+ div.documentwrapper,
+ div.bodywrapper {
+ margin: 0 !important;
+ width: 100%;
+ }
+
+ div.sphinxsidebar,
+ div.related,
+ div.footer,
+ #top-link {
+ display: none;
+ }
+}
\ No newline at end of file
diff --git a/0.2.0/_static/doctools.js b/0.2.0/_static/doctools.js
new file mode 100644
index 0000000..d06a71d
--- /dev/null
+++ b/0.2.0/_static/doctools.js
@@ -0,0 +1,156 @@
+/*
+ * doctools.js
+ * ~~~~~~~~~~~
+ *
+ * Base JavaScript utilities for all Sphinx HTML documentation.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+"use strict";
+
+const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([
+ "TEXTAREA",
+ "INPUT",
+ "SELECT",
+ "BUTTON",
+]);
+
+const _ready = (callback) => {
+ if (document.readyState !== "loading") {
+ callback();
+ } else {
+ document.addEventListener("DOMContentLoaded", callback);
+ }
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const Documentation = {
+ init: () => {
+ Documentation.initDomainIndexTable();
+ Documentation.initOnKeyListeners();
+ },
+
+ /**
+ * i18n support
+ */
+ TRANSLATIONS: {},
+ PLURAL_EXPR: (n) => (n === 1 ? 0 : 1),
+ LOCALE: "unknown",
+
+ // gettext and ngettext don't access this so that the functions
+ // can safely bound to a different name (_ = Documentation.gettext)
+ gettext: (string) => {
+ const translated = Documentation.TRANSLATIONS[string];
+ switch (typeof translated) {
+ case "undefined":
+ return string; // no translation
+ case "string":
+ return translated; // translation exists
+ default:
+ return translated[0]; // (singular, plural) translation tuple exists
+ }
+ },
+
+ ngettext: (singular, plural, n) => {
+ const translated = Documentation.TRANSLATIONS[singular];
+ if (typeof translated !== "undefined")
+ return translated[Documentation.PLURAL_EXPR(n)];
+ return n === 1 ? singular : plural;
+ },
+
+ addTranslations: (catalog) => {
+ Object.assign(Documentation.TRANSLATIONS, catalog.messages);
+ Documentation.PLURAL_EXPR = new Function(
+ "n",
+ `return (${catalog.plural_expr})`
+ );
+ Documentation.LOCALE = catalog.locale;
+ },
+
+ /**
+ * helper function to focus on search bar
+ */
+ focusSearchBar: () => {
+ document.querySelectorAll("input[name=q]")[0]?.focus();
+ },
+
+ /**
+ * Initialise the domain index toggle buttons
+ */
+ initDomainIndexTable: () => {
+ const toggler = (el) => {
+ const idNumber = el.id.substr(7);
+ const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`);
+ if (el.src.substr(-9) === "minus.png") {
+ el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`;
+ toggledRows.forEach((el) => (el.style.display = "none"));
+ } else {
+ el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`;
+ toggledRows.forEach((el) => (el.style.display = ""));
+ }
+ };
+
+ const togglerElements = document.querySelectorAll("img.toggler");
+ togglerElements.forEach((el) =>
+ el.addEventListener("click", (event) => toggler(event.currentTarget))
+ );
+ togglerElements.forEach((el) => (el.style.display = ""));
+ if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler);
+ },
+
+ initOnKeyListeners: () => {
+ // only install a listener if it is really needed
+ if (
+ !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
+ !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS
+ )
+ return;
+
+ document.addEventListener("keydown", (event) => {
+ // bail for input elements
+ if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+ // bail with special keys
+ if (event.altKey || event.ctrlKey || event.metaKey) return;
+
+ if (!event.shiftKey) {
+ switch (event.key) {
+ case "ArrowLeft":
+ if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+ const prevLink = document.querySelector('link[rel="prev"]');
+ if (prevLink && prevLink.href) {
+ window.location.href = prevLink.href;
+ event.preventDefault();
+ }
+ break;
+ case "ArrowRight":
+ if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+ const nextLink = document.querySelector('link[rel="next"]');
+ if (nextLink && nextLink.href) {
+ window.location.href = nextLink.href;
+ event.preventDefault();
+ }
+ break;
+ }
+ }
+
+ // some keyboard layouts may need Shift to get /
+ switch (event.key) {
+ case "/":
+ if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break;
+ Documentation.focusSearchBar();
+ event.preventDefault();
+ }
+ });
+ },
+};
+
+// quick alias for translations
+const _ = Documentation.gettext;
+
+_ready(Documentation.init);
diff --git a/0.2.0/_static/documentation_options.js b/0.2.0/_static/documentation_options.js
new file mode 100644
index 0000000..902bb33
--- /dev/null
+++ b/0.2.0/_static/documentation_options.js
@@ -0,0 +1,14 @@
+var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
+ VERSION: '',
+ LANGUAGE: 'en',
+ COLLAPSE_INDEX: false,
+ BUILDER: 'html',
+ FILE_SUFFIX: '.html',
+ LINK_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt',
+ NAVIGATION_WITH_KEYS: true,
+ SHOW_SEARCH_SUMMARY: true,
+ ENABLE_SEARCH_SHORTCUTS: true,
+};
\ No newline at end of file
diff --git a/0.2.0/_static/file.png b/0.2.0/_static/file.png
new file mode 100644
index 0000000..a858a41
Binary files /dev/null and b/0.2.0/_static/file.png differ
diff --git a/0.2.0/_static/language_data.js b/0.2.0/_static/language_data.js
new file mode 100644
index 0000000..250f566
--- /dev/null
+++ b/0.2.0/_static/language_data.js
@@ -0,0 +1,199 @@
+/*
+ * language_data.js
+ * ~~~~~~~~~~~~~~~~
+ *
+ * This script contains the language-specific data used by searchtools.js,
+ * namely the list of stopwords, stemmer, scorer and splitter.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"];
+
+
+/* Non-minified version is copied as a separate JS file, is available */
+
+/**
+ * Porter Stemmer
+ */
+var Stemmer = function() {
+
+ var step2list = {
+ ational: 'ate',
+ tional: 'tion',
+ enci: 'ence',
+ anci: 'ance',
+ izer: 'ize',
+ bli: 'ble',
+ alli: 'al',
+ entli: 'ent',
+ eli: 'e',
+ ousli: 'ous',
+ ization: 'ize',
+ ation: 'ate',
+ ator: 'ate',
+ alism: 'al',
+ iveness: 'ive',
+ fulness: 'ful',
+ ousness: 'ous',
+ aliti: 'al',
+ iviti: 'ive',
+ biliti: 'ble',
+ logi: 'log'
+ };
+
+ var step3list = {
+ icate: 'ic',
+ ative: '',
+ alize: 'al',
+ iciti: 'ic',
+ ical: 'ic',
+ ful: '',
+ ness: ''
+ };
+
+ var c = "[^aeiou]"; // consonant
+ var v = "[aeiouy]"; // vowel
+ var C = c + "[^aeiouy]*"; // consonant sequence
+ var V = v + "[aeiou]*"; // vowel sequence
+
+ var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
+ var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
+ var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
+ var s_v = "^(" + C + ")?" + v; // vowel in stem
+
+ this.stemWord = function (w) {
+ var stem;
+ var suffix;
+ var firstch;
+ var origword = w;
+
+ if (w.length < 3)
+ return w;
+
+ var re;
+ var re2;
+ var re3;
+ var re4;
+
+ firstch = w.substr(0,1);
+ if (firstch == "y")
+ w = firstch.toUpperCase() + w.substr(1);
+
+ // Step 1a
+ re = /^(.+?)(ss|i)es$/;
+ re2 = /^(.+?)([^s])s$/;
+
+ if (re.test(w))
+ w = w.replace(re,"$1$2");
+ else if (re2.test(w))
+ w = w.replace(re2,"$1$2");
+
+ // Step 1b
+ re = /^(.+?)eed$/;
+ re2 = /^(.+?)(ed|ing)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ re = new RegExp(mgr0);
+ if (re.test(fp[1])) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1];
+ re2 = new RegExp(s_v);
+ if (re2.test(stem)) {
+ w = stem;
+ re2 = /(at|bl|iz)$/;
+ re3 = new RegExp("([^aeiouylsz])\\1$");
+ re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re2.test(w))
+ w = w + "e";
+ else if (re3.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ else if (re4.test(w))
+ w = w + "e";
+ }
+ }
+
+ // Step 1c
+ re = /^(.+?)y$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(s_v);
+ if (re.test(stem))
+ w = stem + "i";
+ }
+
+ // Step 2
+ re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step2list[suffix];
+ }
+
+ // Step 3
+ re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step3list[suffix];
+ }
+
+ // Step 4
+ re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ re2 = /^(.+?)(s|t)(ion)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ if (re.test(stem))
+ w = stem;
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1] + fp[2];
+ re2 = new RegExp(mgr1);
+ if (re2.test(stem))
+ w = stem;
+ }
+
+ // Step 5
+ re = /^(.+?)e$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ re2 = new RegExp(meq1);
+ re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
+ w = stem;
+ }
+ re = /ll$/;
+ re2 = new RegExp(mgr1);
+ if (re.test(w) && re2.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+
+ // and turn initial Y back to y
+ if (firstch == "y")
+ w = firstch.toLowerCase() + w.substr(1);
+ return w;
+ }
+}
+
diff --git a/0.2.0/_static/minus.png b/0.2.0/_static/minus.png
new file mode 100644
index 0000000..d96755f
Binary files /dev/null and b/0.2.0/_static/minus.png differ
diff --git a/0.2.0/_static/plus.png b/0.2.0/_static/plus.png
new file mode 100644
index 0000000..7107cec
Binary files /dev/null and b/0.2.0/_static/plus.png differ
diff --git a/0.2.0/_static/pygments.css b/0.2.0/_static/pygments.css
new file mode 100644
index 0000000..997797f
--- /dev/null
+++ b/0.2.0/_static/pygments.css
@@ -0,0 +1,152 @@
+html[data-theme="light"] .highlight pre { line-height: 125%; }
+html[data-theme="light"] .highlight td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+html[data-theme="light"] .highlight span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+html[data-theme="light"] .highlight td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+html[data-theme="light"] .highlight span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+html[data-theme="light"] .highlight .hll { background-color: #7971292e }
+html[data-theme="light"] .highlight { background: #fefefe; color: #545454 }
+html[data-theme="light"] .highlight .c { color: #797129 } /* Comment */
+html[data-theme="light"] .highlight .err { color: #d91e18 } /* Error */
+html[data-theme="light"] .highlight .k { color: #7928a1 } /* Keyword */
+html[data-theme="light"] .highlight .l { color: #797129 } /* Literal */
+html[data-theme="light"] .highlight .n { color: #545454 } /* Name */
+html[data-theme="light"] .highlight .o { color: #008000 } /* Operator */
+html[data-theme="light"] .highlight .p { color: #545454 } /* Punctuation */
+html[data-theme="light"] .highlight .ch { color: #797129 } /* Comment.Hashbang */
+html[data-theme="light"] .highlight .cm { color: #797129 } /* Comment.Multiline */
+html[data-theme="light"] .highlight .cp { color: #797129 } /* Comment.Preproc */
+html[data-theme="light"] .highlight .cpf { color: #797129 } /* Comment.PreprocFile */
+html[data-theme="light"] .highlight .c1 { color: #797129 } /* Comment.Single */
+html[data-theme="light"] .highlight .cs { color: #797129 } /* Comment.Special */
+html[data-theme="light"] .highlight .gd { color: #007faa } /* Generic.Deleted */
+html[data-theme="light"] .highlight .ge { font-style: italic } /* Generic.Emph */
+html[data-theme="light"] .highlight .gh { color: #007faa } /* Generic.Heading */
+html[data-theme="light"] .highlight .gs { font-weight: bold } /* Generic.Strong */
+html[data-theme="light"] .highlight .gu { color: #007faa } /* Generic.Subheading */
+html[data-theme="light"] .highlight .kc { color: #7928a1 } /* Keyword.Constant */
+html[data-theme="light"] .highlight .kd { color: #7928a1 } /* Keyword.Declaration */
+html[data-theme="light"] .highlight .kn { color: #7928a1 } /* Keyword.Namespace */
+html[data-theme="light"] .highlight .kp { color: #7928a1 } /* Keyword.Pseudo */
+html[data-theme="light"] .highlight .kr { color: #7928a1 } /* Keyword.Reserved */
+html[data-theme="light"] .highlight .kt { color: #797129 } /* Keyword.Type */
+html[data-theme="light"] .highlight .ld { color: #797129 } /* Literal.Date */
+html[data-theme="light"] .highlight .m { color: #797129 } /* Literal.Number */
+html[data-theme="light"] .highlight .s { color: #008000 } /* Literal.String */
+html[data-theme="light"] .highlight .na { color: #797129 } /* Name.Attribute */
+html[data-theme="light"] .highlight .nb { color: #797129 } /* Name.Builtin */
+html[data-theme="light"] .highlight .nc { color: #007faa } /* Name.Class */
+html[data-theme="light"] .highlight .no { color: #007faa } /* Name.Constant */
+html[data-theme="light"] .highlight .nd { color: #797129 } /* Name.Decorator */
+html[data-theme="light"] .highlight .ni { color: #008000 } /* Name.Entity */
+html[data-theme="light"] .highlight .ne { color: #7928a1 } /* Name.Exception */
+html[data-theme="light"] .highlight .nf { color: #007faa } /* Name.Function */
+html[data-theme="light"] .highlight .nl { color: #797129 } /* Name.Label */
+html[data-theme="light"] .highlight .nn { color: #545454 } /* Name.Namespace */
+html[data-theme="light"] .highlight .nx { color: #545454 } /* Name.Other */
+html[data-theme="light"] .highlight .py { color: #007faa } /* Name.Property */
+html[data-theme="light"] .highlight .nt { color: #007faa } /* Name.Tag */
+html[data-theme="light"] .highlight .nv { color: #d91e18 } /* Name.Variable */
+html[data-theme="light"] .highlight .ow { color: #7928a1 } /* Operator.Word */
+html[data-theme="light"] .highlight .pm { color: #545454 } /* Punctuation.Marker */
+html[data-theme="light"] .highlight .w { color: #545454 } /* Text.Whitespace */
+html[data-theme="light"] .highlight .mb { color: #797129 } /* Literal.Number.Bin */
+html[data-theme="light"] .highlight .mf { color: #797129 } /* Literal.Number.Float */
+html[data-theme="light"] .highlight .mh { color: #797129 } /* Literal.Number.Hex */
+html[data-theme="light"] .highlight .mi { color: #797129 } /* Literal.Number.Integer */
+html[data-theme="light"] .highlight .mo { color: #797129 } /* Literal.Number.Oct */
+html[data-theme="light"] .highlight .sa { color: #008000 } /* Literal.String.Affix */
+html[data-theme="light"] .highlight .sb { color: #008000 } /* Literal.String.Backtick */
+html[data-theme="light"] .highlight .sc { color: #008000 } /* Literal.String.Char */
+html[data-theme="light"] .highlight .dl { color: #008000 } /* Literal.String.Delimiter */
+html[data-theme="light"] .highlight .sd { color: #008000 } /* Literal.String.Doc */
+html[data-theme="light"] .highlight .s2 { color: #008000 } /* Literal.String.Double */
+html[data-theme="light"] .highlight .se { color: #008000 } /* Literal.String.Escape */
+html[data-theme="light"] .highlight .sh { color: #008000 } /* Literal.String.Heredoc */
+html[data-theme="light"] .highlight .si { color: #008000 } /* Literal.String.Interpol */
+html[data-theme="light"] .highlight .sx { color: #008000 } /* Literal.String.Other */
+html[data-theme="light"] .highlight .sr { color: #d91e18 } /* Literal.String.Regex */
+html[data-theme="light"] .highlight .s1 { color: #008000 } /* Literal.String.Single */
+html[data-theme="light"] .highlight .ss { color: #007faa } /* Literal.String.Symbol */
+html[data-theme="light"] .highlight .bp { color: #797129 } /* Name.Builtin.Pseudo */
+html[data-theme="light"] .highlight .fm { color: #007faa } /* Name.Function.Magic */
+html[data-theme="light"] .highlight .vc { color: #d91e18 } /* Name.Variable.Class */
+html[data-theme="light"] .highlight .vg { color: #d91e18 } /* Name.Variable.Global */
+html[data-theme="light"] .highlight .vi { color: #d91e18 } /* Name.Variable.Instance */
+html[data-theme="light"] .highlight .vm { color: #797129 } /* Name.Variable.Magic */
+html[data-theme="light"] .highlight .il { color: #797129 } /* Literal.Number.Integer.Long */
+html[data-theme="dark"] .highlight pre { line-height: 125%; }
+html[data-theme="dark"] .highlight td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+html[data-theme="dark"] .highlight span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+html[data-theme="dark"] .highlight td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+html[data-theme="dark"] .highlight span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+html[data-theme="dark"] .highlight .hll { background-color: #ffd9002e }
+html[data-theme="dark"] .highlight { background: #2b2b2b; color: #f8f8f2 }
+html[data-theme="dark"] .highlight .c { color: #ffd900 } /* Comment */
+html[data-theme="dark"] .highlight .err { color: #ffa07a } /* Error */
+html[data-theme="dark"] .highlight .k { color: #dcc6e0 } /* Keyword */
+html[data-theme="dark"] .highlight .l { color: #ffd900 } /* Literal */
+html[data-theme="dark"] .highlight .n { color: #f8f8f2 } /* Name */
+html[data-theme="dark"] .highlight .o { color: #abe338 } /* Operator */
+html[data-theme="dark"] .highlight .p { color: #f8f8f2 } /* Punctuation */
+html[data-theme="dark"] .highlight .ch { color: #ffd900 } /* Comment.Hashbang */
+html[data-theme="dark"] .highlight .cm { color: #ffd900 } /* Comment.Multiline */
+html[data-theme="dark"] .highlight .cp { color: #ffd900 } /* Comment.Preproc */
+html[data-theme="dark"] .highlight .cpf { color: #ffd900 } /* Comment.PreprocFile */
+html[data-theme="dark"] .highlight .c1 { color: #ffd900 } /* Comment.Single */
+html[data-theme="dark"] .highlight .cs { color: #ffd900 } /* Comment.Special */
+html[data-theme="dark"] .highlight .gd { color: #00e0e0 } /* Generic.Deleted */
+html[data-theme="dark"] .highlight .ge { font-style: italic } /* Generic.Emph */
+html[data-theme="dark"] .highlight .gh { color: #00e0e0 } /* Generic.Heading */
+html[data-theme="dark"] .highlight .gs { font-weight: bold } /* Generic.Strong */
+html[data-theme="dark"] .highlight .gu { color: #00e0e0 } /* Generic.Subheading */
+html[data-theme="dark"] .highlight .kc { color: #dcc6e0 } /* Keyword.Constant */
+html[data-theme="dark"] .highlight .kd { color: #dcc6e0 } /* Keyword.Declaration */
+html[data-theme="dark"] .highlight .kn { color: #dcc6e0 } /* Keyword.Namespace */
+html[data-theme="dark"] .highlight .kp { color: #dcc6e0 } /* Keyword.Pseudo */
+html[data-theme="dark"] .highlight .kr { color: #dcc6e0 } /* Keyword.Reserved */
+html[data-theme="dark"] .highlight .kt { color: #ffd900 } /* Keyword.Type */
+html[data-theme="dark"] .highlight .ld { color: #ffd900 } /* Literal.Date */
+html[data-theme="dark"] .highlight .m { color: #ffd900 } /* Literal.Number */
+html[data-theme="dark"] .highlight .s { color: #abe338 } /* Literal.String */
+html[data-theme="dark"] .highlight .na { color: #ffd900 } /* Name.Attribute */
+html[data-theme="dark"] .highlight .nb { color: #ffd900 } /* Name.Builtin */
+html[data-theme="dark"] .highlight .nc { color: #00e0e0 } /* Name.Class */
+html[data-theme="dark"] .highlight .no { color: #00e0e0 } /* Name.Constant */
+html[data-theme="dark"] .highlight .nd { color: #ffd900 } /* Name.Decorator */
+html[data-theme="dark"] .highlight .ni { color: #abe338 } /* Name.Entity */
+html[data-theme="dark"] .highlight .ne { color: #dcc6e0 } /* Name.Exception */
+html[data-theme="dark"] .highlight .nf { color: #00e0e0 } /* Name.Function */
+html[data-theme="dark"] .highlight .nl { color: #ffd900 } /* Name.Label */
+html[data-theme="dark"] .highlight .nn { color: #f8f8f2 } /* Name.Namespace */
+html[data-theme="dark"] .highlight .nx { color: #f8f8f2 } /* Name.Other */
+html[data-theme="dark"] .highlight .py { color: #00e0e0 } /* Name.Property */
+html[data-theme="dark"] .highlight .nt { color: #00e0e0 } /* Name.Tag */
+html[data-theme="dark"] .highlight .nv { color: #ffa07a } /* Name.Variable */
+html[data-theme="dark"] .highlight .ow { color: #dcc6e0 } /* Operator.Word */
+html[data-theme="dark"] .highlight .pm { color: #f8f8f2 } /* Punctuation.Marker */
+html[data-theme="dark"] .highlight .w { color: #f8f8f2 } /* Text.Whitespace */
+html[data-theme="dark"] .highlight .mb { color: #ffd900 } /* Literal.Number.Bin */
+html[data-theme="dark"] .highlight .mf { color: #ffd900 } /* Literal.Number.Float */
+html[data-theme="dark"] .highlight .mh { color: #ffd900 } /* Literal.Number.Hex */
+html[data-theme="dark"] .highlight .mi { color: #ffd900 } /* Literal.Number.Integer */
+html[data-theme="dark"] .highlight .mo { color: #ffd900 } /* Literal.Number.Oct */
+html[data-theme="dark"] .highlight .sa { color: #abe338 } /* Literal.String.Affix */
+html[data-theme="dark"] .highlight .sb { color: #abe338 } /* Literal.String.Backtick */
+html[data-theme="dark"] .highlight .sc { color: #abe338 } /* Literal.String.Char */
+html[data-theme="dark"] .highlight .dl { color: #abe338 } /* Literal.String.Delimiter */
+html[data-theme="dark"] .highlight .sd { color: #abe338 } /* Literal.String.Doc */
+html[data-theme="dark"] .highlight .s2 { color: #abe338 } /* Literal.String.Double */
+html[data-theme="dark"] .highlight .se { color: #abe338 } /* Literal.String.Escape */
+html[data-theme="dark"] .highlight .sh { color: #abe338 } /* Literal.String.Heredoc */
+html[data-theme="dark"] .highlight .si { color: #abe338 } /* Literal.String.Interpol */
+html[data-theme="dark"] .highlight .sx { color: #abe338 } /* Literal.String.Other */
+html[data-theme="dark"] .highlight .sr { color: #ffa07a } /* Literal.String.Regex */
+html[data-theme="dark"] .highlight .s1 { color: #abe338 } /* Literal.String.Single */
+html[data-theme="dark"] .highlight .ss { color: #00e0e0 } /* Literal.String.Symbol */
+html[data-theme="dark"] .highlight .bp { color: #ffd900 } /* Name.Builtin.Pseudo */
+html[data-theme="dark"] .highlight .fm { color: #00e0e0 } /* Name.Function.Magic */
+html[data-theme="dark"] .highlight .vc { color: #ffa07a } /* Name.Variable.Class */
+html[data-theme="dark"] .highlight .vg { color: #ffa07a } /* Name.Variable.Global */
+html[data-theme="dark"] .highlight .vi { color: #ffa07a } /* Name.Variable.Instance */
+html[data-theme="dark"] .highlight .vm { color: #ffd900 } /* Name.Variable.Magic */
+html[data-theme="dark"] .highlight .il { color: #ffd900 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/0.2.0/_static/scripts/bootstrap.js b/0.2.0/_static/scripts/bootstrap.js
new file mode 100644
index 0000000..766173a
--- /dev/null
+++ b/0.2.0/_static/scripts/bootstrap.js
@@ -0,0 +1,3 @@
+/*! For license information please see bootstrap.js.LICENSE.txt */
+(()=>{"use strict";var t={d:(e,i)=>{for(var n in i)t.o(i,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:i[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{afterMain:()=>w,afterRead:()=>b,afterWrite:()=>C,applyStyles:()=>$,arrow:()=>G,auto:()=>r,basePlacements:()=>a,beforeMain:()=>v,bef [...]
+//# sourceMappingURL=bootstrap.js.map
\ No newline at end of file
diff --git a/0.2.0/_static/scripts/bootstrap.js.LICENSE.txt b/0.2.0/_static/scripts/bootstrap.js.LICENSE.txt
new file mode 100644
index 0000000..91ad10a
--- /dev/null
+++ b/0.2.0/_static/scripts/bootstrap.js.LICENSE.txt
@@ -0,0 +1,5 @@
+/*!
+ * Bootstrap v5.2.3 (https://getbootstrap.com/)
+ * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */
diff --git a/0.2.0/_static/scripts/bootstrap.js.map b/0.2.0/_static/scripts/bootstrap.js.map
new file mode 100644
index 0000000..d83e2f7
--- /dev/null
+++ b/0.2.0/_static/scripts/bootstrap.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"scripts/bootstrap.js","mappings":";mBACA,IAAIA,EAAsB,CCA1BA,EAAwB,CAACC,EAASC,KACjC,IAAI,IAAIC,KAAOD,EACXF,EAAoBI,EAAEF,EAAYC,KAASH,EAAoBI,EAAEH,EAASE,IAC5EE,OAAOC,eAAeL,EAASE,EAAK,CAAEI,YAAY,EAAMC,IAAKN,EAAWC,IAE1E,ECNDH,EAAwB,CAACS,EAAKC,IAAUL,OAAOM,UAAUC,eAAeC,KAAKJ,EAAKC,GCClFV,EAAyBC,IACH,oBAAXa,QAA0BA,OAAOC,aAC1CV,OAAOC,eAAeL,EAASa,OAAOC,YAAa,CAAEC,MAAO,WAE7DX,OAAOC,eAAeL,EAAS,aAAc,CAAEe,OAAO,GAAO,ipBCLvD,IAAI,EAAM,MACNC,EAAS,SACTC,EAAQ,QACRC,EAAO,OACPC,EAAO,OA [...]
\ No newline at end of file
diff --git a/0.2.0/_static/scripts/pydata-sphinx-theme.js b/0.2.0/_static/scripts/pydata-sphinx-theme.js
new file mode 100644
index 0000000..3cbeb9b
--- /dev/null
+++ b/0.2.0/_static/scripts/pydata-sphinx-theme.js
@@ -0,0 +1,2 @@
+(()=>{"use strict";function e(e){"loading"!=document.readyState?e():document.addEventListener("DOMContentLoaded",e)}var t=window.matchMedia("(prefers-color-scheme: dark)");function o(e){document.documentElement.dataset.theme=t.matches?"dark":"light"}function n(e){"light"!==e&&"dark"!==e&&"auto"!==e&&(console.error(`Got invalid theme mode: ${e}. Resetting to auto.`),e="auto");var n=t.matches?"dark":"light";document.documentElement.dataset.mode=e;var r="auto"==e?n:e;document.documentElemen [...]
+//# sourceMappingURL=pydata-sphinx-theme.js.map
\ No newline at end of file
diff --git a/0.2.0/_static/scripts/pydata-sphinx-theme.js.map b/0.2.0/_static/scripts/pydata-sphinx-theme.js.map
new file mode 100644
index 0000000..418212a
--- /dev/null
+++ b/0.2.0/_static/scripts/pydata-sphinx-theme.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"scripts/pydata-sphinx-theme.js","mappings":"mBASO,SAASA,EAAcC,GACD,WAAvBC,SAASC,WAAyBF,IACjCC,SAASE,iBAAiB,mBAAoBH,EACrD,CCHA,IAAII,EAAcC,OAAOC,WAAW,gCAOpC,SAASC,EAAUC,GACjBP,SAASQ,gBAAgBC,QAAQC,MAAQP,EAAYQ,QACjD,OACA,OACN,CAQA,SAASC,EAASC,GACH,UAATA,GAA6B,SAATA,GAA4B,SAATA,IACzCC,QAAQC,MAAM,2BAA2BF,yBACzCA,EAAO,QAIT,IAAIG,EAAcb,EAAYQ,QAAU,OAAS,QACjDX,SAASQ,gBAAgBC,QAAQI,KAAOA,EACxC,IAAIH,EAAgB,QAARG,EAAiBG,EAAcH,EAC3Cb,SAASQ,gBAAgBC,QAAQC,MAAQA,EAGzCO,aAAaC,QAAQ,OAA [...]
\ No newline at end of file
diff --git a/0.2.0/_static/searchtools.js b/0.2.0/_static/searchtools.js
new file mode 100644
index 0000000..97d56a7
--- /dev/null
+++ b/0.2.0/_static/searchtools.js
@@ -0,0 +1,566 @@
+/*
+ * searchtools.js
+ * ~~~~~~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilities for the full-text search.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+"use strict";
+
+/**
+ * Simple result scoring code.
+ */
+if (typeof Scorer === "undefined") {
+ var Scorer = {
+ // Implement the following function to further tweak the score for each result
+ // The function takes a result array [docname, title, anchor, descr, score, filename]
+ // and returns the new score.
+ /*
+ score: result => {
+ const [docname, title, anchor, descr, score, filename] = result
+ return score
+ },
+ */
+
+ // query matches the full name of an object
+ objNameMatch: 11,
+ // or matches in the last dotted part of the object name
+ objPartialMatch: 6,
+ // Additive scores depending on the priority of the object
+ objPrio: {
+ 0: 15, // used to be importantResults
+ 1: 5, // used to be objectResults
+ 2: -5, // used to be unimportantResults
+ },
+ // Used when the priority is not in the mapping.
+ objPrioDefault: 0,
+
+ // query found in title
+ title: 15,
+ partialTitle: 7,
+ // query found in terms
+ term: 5,
+ partialTerm: 2,
+ };
+}
+
+const _removeChildren = (element) => {
+ while (element && element.lastChild) element.removeChild(element.lastChild);
+};
+
+/**
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+ */
+const _escapeRegExp = (string) =>
+ string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+
+const _displayItem = (item, searchTerms) => {
+ const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
+ const docUrlRoot = DOCUMENTATION_OPTIONS.URL_ROOT;
+ const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+ const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
+ const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
+
+ const [docName, title, anchor, descr, score, _filename] = item;
+
+ let listItem = document.createElement("li");
+ let requestUrl;
+ let linkUrl;
+ if (docBuilder === "dirhtml") {
+ // dirhtml builder
+ let dirname = docName + "/";
+ if (dirname.match(/\/index\/$/))
+ dirname = dirname.substring(0, dirname.length - 6);
+ else if (dirname === "index/") dirname = "";
+ requestUrl = docUrlRoot + dirname;
+ linkUrl = requestUrl;
+ } else {
+ // normal html builders
+ requestUrl = docUrlRoot + docName + docFileSuffix;
+ linkUrl = docName + docLinkSuffix;
+ }
+ let linkEl = listItem.appendChild(document.createElement("a"));
+ linkEl.href = linkUrl + anchor;
+ linkEl.dataset.score = score;
+ linkEl.innerHTML = title;
+ if (descr)
+ listItem.appendChild(document.createElement("span")).innerHTML =
+ " (" + descr + ")";
+ else if (showSearchSummary)
+ fetch(requestUrl)
+ .then((responseData) => responseData.text())
+ .then((data) => {
+ if (data)
+ listItem.appendChild(
+ Search.makeSearchSummary(data, searchTerms)
+ );
+ });
+ Search.output.appendChild(listItem);
+};
+const _finishSearch = (resultCount) => {
+ Search.stopPulse();
+ Search.title.innerText = _("Search Results");
+ if (!resultCount)
+ Search.status.innerText = Documentation.gettext(
+ "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories."
+ );
+ else
+ Search.status.innerText = _(
+ `Search finished, found ${resultCount} page(s) matching the search query.`
+ );
+};
+const _displayNextItem = (
+ results,
+ resultCount,
+ searchTerms
+) => {
+ // results left, load the summary and display it
+ // this is intended to be dynamic (don't sub resultsCount)
+ if (results.length) {
+ _displayItem(results.pop(), searchTerms);
+ setTimeout(
+ () => _displayNextItem(results, resultCount, searchTerms),
+ 5
+ );
+ }
+ // search finished, update title and status message
+ else _finishSearch(resultCount);
+};
+
+/**
+ * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
+ * custom function per language.
+ *
+ * The regular expression works by splitting the string on consecutive characters
+ * that are not Unicode letters, numbers, underscores, or emoji characters.
+ * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
+ */
+if (typeof splitQuery === "undefined") {
+ var splitQuery = (query) => query
+ .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
+ .filter(term => term) // remove remaining empty strings
+}
+
+/**
+ * Search Module
+ */
+const Search = {
+ _index: null,
+ _queued_query: null,
+ _pulse_status: -1,
+
+ htmlToText: (htmlString) => {
+ const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
+ htmlElement.querySelectorAll(".headerlink").forEach((el) => { el.remove() });
+ const docContent = htmlElement.querySelector('[role="main"]');
+ if (docContent !== undefined) return docContent.textContent;
+ console.warn(
+ "Content block not found. Sphinx search tries to obtain it via '[role=main]'. Could you check your theme or template."
+ );
+ return "";
+ },
+
+ init: () => {
+ const query = new URLSearchParams(window.location.search).get("q");
+ document
+ .querySelectorAll('input[name="q"]')
+ .forEach((el) => (el.value = query));
+ if (query) Search.performSearch(query);
+ },
+
+ loadIndex: (url) =>
+ (document.body.appendChild(document.createElement("script")).src = url),
+
+ setIndex: (index) => {
+ Search._index = index;
+ if (Search._queued_query !== null) {
+ const query = Search._queued_query;
+ Search._queued_query = null;
+ Search.query(query);
+ }
+ },
+
+ hasIndex: () => Search._index !== null,
+
+ deferQuery: (query) => (Search._queued_query = query),
+
+ stopPulse: () => (Search._pulse_status = -1),
+
+ startPulse: () => {
+ if (Search._pulse_status >= 0) return;
+
+ const pulse = () => {
+ Search._pulse_status = (Search._pulse_status + 1) % 4;
+ Search.dots.innerText = ".".repeat(Search._pulse_status);
+ if (Search._pulse_status >= 0) window.setTimeout(pulse, 500);
+ };
+ pulse();
+ },
+
+ /**
+ * perform a search for something (or wait until index is loaded)
+ */
+ performSearch: (query) => {
+ // create the required interface elements
+ const searchText = document.createElement("h2");
+ searchText.textContent = _("Searching");
+ const searchSummary = document.createElement("p");
+ searchSummary.classList.add("search-summary");
+ searchSummary.innerText = "";
+ const searchList = document.createElement("ul");
+ searchList.classList.add("search");
+
+ const out = document.getElementById("search-results");
+ Search.title = out.appendChild(searchText);
+ Search.dots = Search.title.appendChild(document.createElement("span"));
+ Search.status = out.appendChild(searchSummary);
+ Search.output = out.appendChild(searchList);
+
+ const searchProgress = document.getElementById("search-progress");
+ // Some themes don't use the search progress node
+ if (searchProgress) {
+ searchProgress.innerText = _("Preparing search...");
+ }
+ Search.startPulse();
+
+ // index already loaded, the browser was quick!
+ if (Search.hasIndex()) Search.query(query);
+ else Search.deferQuery(query);
+ },
+
+ /**
+ * execute search (requires search index to be loaded)
+ */
+ query: (query) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+ const allTitles = Search._index.alltitles;
+ const indexEntries = Search._index.indexentries;
+
+ // stem the search terms and add them to the correct list
+ const stemmer = new Stemmer();
+ const searchTerms = new Set();
+ const excludedTerms = new Set();
+ const highlightTerms = new Set();
+ const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
+ splitQuery(query.trim()).forEach((queryTerm) => {
+ const queryTermLower = queryTerm.toLowerCase();
+
+ // maybe skip this "word"
+ // stopwords array is from language_data.js
+ if (
+ stopwords.indexOf(queryTermLower) !== -1 ||
+ queryTerm.match(/^\d+$/)
+ )
+ return;
+
+ // stem the word
+ let word = stemmer.stemWord(queryTermLower);
+ // select the correct list
+ if (word[0] === "-") excludedTerms.add(word.substr(1));
+ else {
+ searchTerms.add(word);
+ highlightTerms.add(queryTermLower);
+ }
+ });
+
+ if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js
+ localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" "))
+ }
+
+ // console.debug("SEARCH: searching for:");
+ // console.info("required: ", [...searchTerms]);
+ // console.info("excluded: ", [...excludedTerms]);
+
+ // array of [docname, title, anchor, descr, score, filename]
+ let results = [];
+ _removeChildren(document.getElementById("search-progress"));
+
+ const queryLower = query.toLowerCase();
+ for (const [title, foundTitles] of Object.entries(allTitles)) {
+ if (title.toLowerCase().includes(queryLower) && (queryLower.length >= title.length/2)) {
+ for (const [file, id] of foundTitles) {
+ let score = Math.round(100 * queryLower.length / title.length)
+ results.push([
+ docNames[file],
+ titles[file] !== title ? `${titles[file]} > ${title}` : title,
+ id !== null ? "#" + id : "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ }
+ }
+
+ // search for explicit entries in index directives
+ for (const [entry, foundEntries] of Object.entries(indexEntries)) {
+ if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) {
+ for (const [file, id] of foundEntries) {
+ let score = Math.round(100 * queryLower.length / entry.length)
+ results.push([
+ docNames[file],
+ titles[file],
+ id ? "#" + id : "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ }
+ }
+
+ // lookup as object
+ objectTerms.forEach((term) =>
+ results.push(...Search.performObjectSearch(term, objectTerms))
+ );
+
+ // lookup as search terms in fulltext
+ results.push(...Search.performTermsSearch(searchTerms, excludedTerms));
+
+ // let the scorer override scores with a custom scoring function
+ if (Scorer.score) results.forEach((item) => (item[4] = Scorer.score(item)));
+
+ // now sort the results by score (in opposite order of appearance, since the
+ // display function below uses pop() to retrieve items) and then
+ // alphabetically
+ results.sort((a, b) => {
+ const leftScore = a[4];
+ const rightScore = b[4];
+ if (leftScore === rightScore) {
+ // same score: sort alphabetically
+ const leftTitle = a[1].toLowerCase();
+ const rightTitle = b[1].toLowerCase();
+ if (leftTitle === rightTitle) return 0;
+ return leftTitle > rightTitle ? -1 : 1; // inverted is intentional
+ }
+ return leftScore > rightScore ? 1 : -1;
+ });
+
+ // remove duplicate search results
+ // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
+ let seen = new Set();
+ results = results.reverse().reduce((acc, result) => {
+ let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(',');
+ if (!seen.has(resultStr)) {
+ acc.push(result);
+ seen.add(resultStr);
+ }
+ return acc;
+ }, []);
+
+ results = results.reverse();
+
+ // for debugging
+ //Search.lastresults = results.slice(); // a copy
+ // console.info("search results:", Search.lastresults);
+
+ // print the results
+ _displayNextItem(results, results.length, searchTerms);
+ },
+
+ /**
+ * search for object names
+ */
+ performObjectSearch: (object, objectTerms) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const objects = Search._index.objects;
+ const objNames = Search._index.objnames;
+ const titles = Search._index.titles;
+
+ const results = [];
+
+ const objectSearchCallback = (prefix, match) => {
+ const name = match[4]
+ const fullname = (prefix ? prefix + "." : "") + name;
+ const fullnameLower = fullname.toLowerCase();
+ if (fullnameLower.indexOf(object) < 0) return;
+
+ let score = 0;
+ const parts = fullnameLower.split(".");
+
+ // check for different match types: exact matches of full name or
+ // "last name" (i.e. last dotted part)
+ if (fullnameLower === object || parts.slice(-1)[0] === object)
+ score += Scorer.objNameMatch;
+ else if (parts.slice(-1)[0].indexOf(object) > -1)
+ score += Scorer.objPartialMatch; // matches in last name
+
+ const objName = objNames[match[1]][2];
+ const title = titles[match[0]];
+
+ // If more than one term searched for, we require other words to be
+ // found in the name/title/description
+ const otherTerms = new Set(objectTerms);
+ otherTerms.delete(object);
+ if (otherTerms.size > 0) {
+ const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
+ if (
+ [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0)
+ )
+ return;
+ }
+
+ let anchor = match[3];
+ if (anchor === "") anchor = fullname;
+ else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname;
+
+ const descr = objName + _(", in ") + title;
+
+ // add custom score for some objects according to scorer
+ if (Scorer.objPrio.hasOwnProperty(match[2]))
+ score += Scorer.objPrio[match[2]];
+ else score += Scorer.objPrioDefault;
+
+ results.push([
+ docNames[match[0]],
+ fullname,
+ "#" + anchor,
+ descr,
+ score,
+ filenames[match[0]],
+ ]);
+ };
+ Object.keys(objects).forEach((prefix) =>
+ objects[prefix].forEach((array) =>
+ objectSearchCallback(prefix, array)
+ )
+ );
+ return results;
+ },
+
+ /**
+ * search for full-text terms in the index
+ */
+ performTermsSearch: (searchTerms, excludedTerms) => {
+ // prepare search
+ const terms = Search._index.terms;
+ const titleTerms = Search._index.titleterms;
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+
+ const scoreMap = new Map();
+ const fileMap = new Map();
+
+ // perform the search on the required terms
+ searchTerms.forEach((word) => {
+ const files = [];
+ const arr = [
+ { files: terms[word], score: Scorer.term },
+ { files: titleTerms[word], score: Scorer.title },
+ ];
+ // add support for partial matches
+ if (word.length > 2) {
+ const escapedWord = _escapeRegExp(word);
+ Object.keys(terms).forEach((term) => {
+ if (term.match(escapedWord) && !terms[word])
+ arr.push({ files: terms[term], score: Scorer.partialTerm });
+ });
+ Object.keys(titleTerms).forEach((term) => {
+ if (term.match(escapedWord) && !titleTerms[word])
+ arr.push({ files: titleTerms[word], score: Scorer.partialTitle });
+ });
+ }
+
+ // no match but word was a required one
+ if (arr.every((record) => record.files === undefined)) return;
+
+ // found search word in contents
+ arr.forEach((record) => {
+ if (record.files === undefined) return;
+
+ let recordFiles = record.files;
+ if (recordFiles.length === undefined) recordFiles = [recordFiles];
+ files.push(...recordFiles);
+
+ // set score for the word in each file
+ recordFiles.forEach((file) => {
+ if (!scoreMap.has(file)) scoreMap.set(file, {});
+ scoreMap.get(file)[word] = record.score;
+ });
+ });
+
+ // create the mapping
+ files.forEach((file) => {
+ if (fileMap.has(file) && fileMap.get(file).indexOf(word) === -1)
+ fileMap.get(file).push(word);
+ else fileMap.set(file, [word]);
+ });
+ });
+
+ // now check if the files don't contain excluded terms
+ const results = [];
+ for (const [file, wordList] of fileMap) {
+ // check if all requirements are matched
+
+ // as search terms with length < 3 are discarded
+ const filteredTermCount = [...searchTerms].filter(
+ (term) => term.length > 2
+ ).length;
+ if (
+ wordList.length !== searchTerms.size &&
+ wordList.length !== filteredTermCount
+ )
+ continue;
+
+ // ensure that none of the excluded terms is in the search result
+ if (
+ [...excludedTerms].some(
+ (term) =>
+ terms[term] === file ||
+ titleTerms[term] === file ||
+ (terms[term] || []).includes(file) ||
+ (titleTerms[term] || []).includes(file)
+ )
+ )
+ break;
+
+ // select one (max) score for the file.
+ const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w]));
+ // add result to the result list
+ results.push([
+ docNames[file],
+ titles[file],
+ "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ return results;
+ },
+
+ /**
+ * helper function to return a node containing the
+ * search summary for a given text. keywords is a list
+ * of stemmed words.
+ */
+ makeSearchSummary: (htmlText, keywords) => {
+ const text = Search.htmlToText(htmlText);
+ if (text === "") return null;
+
+ const textLower = text.toLowerCase();
+ const actualStartPosition = [...keywords]
+ .map((k) => textLower.indexOf(k.toLowerCase()))
+ .filter((i) => i > -1)
+ .slice(-1)[0];
+ const startWithContext = Math.max(actualStartPosition - 120, 0);
+
+ const top = startWithContext === 0 ? "" : "...";
+ const tail = startWithContext + 240 < text.length ? "..." : "";
+
+ let summary = document.createElement("p");
+ summary.classList.add("context");
+ summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;
+
+ return summary;
+ },
+};
+
+_ready(Search.init);
diff --git a/0.2.0/_static/sphinx_highlight.js b/0.2.0/_static/sphinx_highlight.js
new file mode 100644
index 0000000..aae669d
--- /dev/null
+++ b/0.2.0/_static/sphinx_highlight.js
@@ -0,0 +1,144 @@
+/* Highlighting utilities for Sphinx HTML documentation. */
+"use strict";
+
+const SPHINX_HIGHLIGHT_ENABLED = true
+
+/**
+ * highlight a given string on a node by wrapping it in
+ * span elements with the given class name.
+ */
+const _highlight = (node, addItems, text, className) => {
+ if (node.nodeType === Node.TEXT_NODE) {
+ const val = node.nodeValue;
+ const parent = node.parentNode;
+ const pos = val.toLowerCase().indexOf(text);
+ if (
+ pos >= 0 &&
+ !parent.classList.contains(className) &&
+ !parent.classList.contains("nohighlight")
+ ) {
+ let span;
+
+ const closestNode = parent.closest("body, svg, foreignObject");
+ const isInSVG = closestNode && closestNode.matches("svg");
+ if (isInSVG) {
+ span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+ } else {
+ span = document.createElement("span");
+ span.classList.add(className);
+ }
+
+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+ parent.insertBefore(
+ span,
+ parent.insertBefore(
+ document.createTextNode(val.substr(pos + text.length)),
+ node.nextSibling
+ )
+ );
+ node.nodeValue = val.substr(0, pos);
+
+ if (isInSVG) {
+ const rect = document.createElementNS(
+ "http://www.w3.org/2000/svg",
+ "rect"
+ );
+ const bbox = parent.getBBox();
+ rect.x.baseVal.value = bbox.x;
+ rect.y.baseVal.value = bbox.y;
+ rect.width.baseVal.value = bbox.width;
+ rect.height.baseVal.value = bbox.height;
+ rect.setAttribute("class", className);
+ addItems.push({ parent: parent, target: rect });
+ }
+ }
+ } else if (node.matches && !node.matches("button, select, textarea")) {
+ node.childNodes.forEach((el) => _highlight(el, addItems, text, className));
+ }
+};
+const _highlightText = (thisNode, text, className) => {
+ let addItems = [];
+ _highlight(thisNode, addItems, text, className);
+ addItems.forEach((obj) =>
+ obj.parent.insertAdjacentElement("beforebegin", obj.target)
+ );
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const SphinxHighlight = {
+
+ /**
+ * highlight the search words provided in localstorage in the text
+ */
+ highlightSearchWords: () => {
+ if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight
+
+ // get and clear terms from localstorage
+ const url = new URL(window.location);
+ const highlight =
+ localStorage.getItem("sphinx_highlight_terms")
+ || url.searchParams.get("highlight")
+ || "";
+ localStorage.removeItem("sphinx_highlight_terms")
+ url.searchParams.delete("highlight");
+ window.history.replaceState({}, "", url);
+
+ // get individual terms from highlight string
+ const terms = highlight.toLowerCase().split(/\s+/).filter(x => x);
+ if (terms.length === 0) return; // nothing to do
+
+ // There should never be more than one element matching "div.body"
+ const divBody = document.querySelectorAll("div.body");
+ const body = divBody.length ? divBody[0] : document.querySelector("body");
+ window.setTimeout(() => {
+ terms.forEach((term) => _highlightText(body, term, "highlighted"));
+ }, 10);
+
+ const searchBox = document.getElementById("searchbox");
+ if (searchBox === null) return;
+ searchBox.appendChild(
+ document
+ .createRange()
+ .createContextualFragment(
+ '<p class="highlight-link">' +
+ '<a href="javascript:SphinxHighlight.hideSearchWords()">' +
+ _("Hide Search Matches") +
+ "</a></p>"
+ )
+ );
+ },
+
+ /**
+ * helper function to hide the search marks again
+ */
+ hideSearchWords: () => {
+ document
+ .querySelectorAll("#searchbox .highlight-link")
+ .forEach((el) => el.remove());
+ document
+ .querySelectorAll("span.highlighted")
+ .forEach((el) => el.classList.remove("highlighted"));
+ localStorage.removeItem("sphinx_highlight_terms")
+ },
+
+ initEscapeListener: () => {
+ // only install a listener if it is really needed
+ if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return;
+
+ document.addEventListener("keydown", (event) => {
+ // bail for input elements
+ if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+ // bail with special keys
+ if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;
+ if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) {
+ SphinxHighlight.hideSearchWords();
+ event.preventDefault();
+ }
+ });
+ },
+};
+
+_ready(SphinxHighlight.highlightSearchWords);
+_ready(SphinxHighlight.initEscapeListener);
diff --git a/0.2.0/_static/styles/bootstrap.css b/0.2.0/_static/styles/bootstrap.css
new file mode 100644
index 0000000..0aa5f54
--- /dev/null
+++ b/0.2.0/_static/styles/bootstrap.css
@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v5.2.3 (https://getbootstrap.com/)
+ * Copyright 2011-2022 The Bootstrap Authors
+ * Copyright 2011-2022 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */:root{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-black:#000;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-gray-100:#f8f9fa;--bs-gray-200:#e9ecef;--bs-gray-300:#dee2e6;--bs-gray-400:#ced4da;--bs-gray-500:#adb5bd;--bs-gray-600:#6c757d;--bs-gray-700:#495057;--bs-gray-800:#343a40;--bs-gray-900:#212529;--bs-primary:#0d6efd;--b [...]
\ No newline at end of file
diff --git a/0.2.0/_static/styles/pydata-sphinx-theme.css b/0.2.0/_static/styles/pydata-sphinx-theme.css
new file mode 100644
index 0000000..ca295d8
--- /dev/null
+++ b/0.2.0/_static/styles/pydata-sphinx-theme.css
@@ -0,0 +1 @@
+html{--pst-header-height:4rem;--pst-header-article-height:calc(var(--pst-header-height)*2/3);--pst-sidebar-secondary:17rem;--pst-font-size-base:1rem;--pst-font-size-h1:2.5rem;--pst-font-size-h2:2rem;--pst-font-size-h3:1.75rem;--pst-font-size-h4:1.5rem;--pst-font-size-h5:1.25rem;--pst-font-size-h6:1.1rem;--pst-font-size-milli:0.9rem;--pst-sidebar-font-size:0.9rem;--pst-sidebar-font-size-mobile:1.1rem;--pst-sidebar-header-font-size:1.2rem;--pst-sidebar-header-font-weight:600;--pst-admoniti [...]
\ No newline at end of file
diff --git a/0.2.0/_static/styles/theme.css b/0.2.0/_static/styles/theme.css
new file mode 100644
index 0000000..4519dd9
--- /dev/null
+++ b/0.2.0/_static/styles/theme.css
@@ -0,0 +1,2 @@
+/* Provided by Sphinx's 'basic' theme, and included in the final set of assets */
+@import "../basic.css";
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/LICENSE.txt b/0.2.0/_static/vendor/fontawesome/6.1.2/LICENSE.txt
new file mode 100644
index 0000000..cc557ec
--- /dev/null
+++ b/0.2.0/_static/vendor/fontawesome/6.1.2/LICENSE.txt
@@ -0,0 +1,165 @@
+Fonticons, Inc. (https://fontawesome.com)
+
+--------------------------------------------------------------------------------
+
+Font Awesome Free License
+
+Font Awesome Free is free, open source, and GPL friendly. You can use it for
+commercial projects, open source projects, or really almost whatever you want.
+Full Font Awesome Free license: https://fontawesome.com/license/free.
+
+--------------------------------------------------------------------------------
+
+# Icons: CC BY 4.0 License (https://creativecommons.org/licenses/by/4.0/)
+
+The Font Awesome Free download is licensed under a Creative Commons
+Attribution 4.0 International License and applies to all icons packaged
+as SVG and JS file types.
+
+--------------------------------------------------------------------------------
+
+# Fonts: SIL OFL 1.1 License
+
+In the Font Awesome Free download, the SIL OFL license applies to all icons
+packaged as web and desktop font files.
+
+Copyright (c) 2022 Fonticons, Inc. (https://fontawesome.com)
+with Reserved Font Name: "Font Awesome".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+SIL OPEN FONT LICENSE
+Version 1.1 - 26 February 2007
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting — in part or in whole — any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+# Code: MIT License (https://opensource.org/licenses/MIT)
+
+In the Font Awesome Free download, the MIT license applies to all non-font and
+non-icon files.
+
+Copyright 2022 Fonticons, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+# Attribution
+
+Attribution is required by MIT, SIL OFL, and CC BY licenses. Downloaded Font
+Awesome Free files already contain embedded comments with sufficient
+attribution, so you shouldn't need to do anything additional when using these
+files normally.
+
+We've kept attribution comments terse, so we ask that you do not actively work
+to remove them from files, especially code. They're a great way for folks to
+learn about Font Awesome.
+
+--------------------------------------------------------------------------------
+
+# Brand Icons
+
+All brand icons are trademarks of their respective owners. The use of these
+trademarks does not indicate endorsement of the trademark holder by Font
+Awesome, nor vice versa. **Please do not use brand logos for any purpose except
+to represent the company, product, or service to which they refer.**
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/css/all.min.css b/0.2.0/_static/vendor/fontawesome/6.1.2/css/all.min.css
new file mode 100644
index 0000000..aad4b1d
--- /dev/null
+++ b/0.2.0/_static/vendor/fontawesome/6.1.2/css/all.min.css
@@ -0,0 +1,5 @@
+/*!
+ * Font Awesome Free 6.1.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
+ * Copyright 2022 Fonticons, Inc.
+ */.fa{font-family:var(--fa-style-family,"Font Awesome 6 Free");font-weight:var(--fa-style,900)}.fa,.fa-brands,.fa-duotone,.fa-light,.fa-regular,.fa-solid,.fa-thin,.fab,.fad,.fal,.far,.fas,.fat{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:var(--fa-display,inline-block);font-style:normal;font-variant:normal;line-height:1;text-rendering:auto}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-s [...]
\ No newline at end of file
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.ttf b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.ttf
new file mode 100644
index 0000000..24ca8b1
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.ttf differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2 b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2
new file mode 100644
index 0000000..e67e5cd
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2 differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.ttf b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.ttf
new file mode 100644
index 0000000..c5ac009
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.ttf differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2 b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2
new file mode 100644
index 0000000..7dca1d9
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2 differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.ttf b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.ttf
new file mode 100644
index 0000000..43ba1cc
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.ttf differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2 b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2
new file mode 100644
index 0000000..4a7f966
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2 differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.ttf b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.ttf
new file mode 100644
index 0000000..243bc25
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.ttf differ
diff --git a/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.woff2 b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.woff2
new file mode 100644
index 0000000..e18a16d
Binary files /dev/null and b/0.2.0/_static/vendor/fontawesome/6.1.2/webfonts/fa-v4compatibility.woff2 differ
diff --git a/0.2.0/_static/webpack-macros.html b/0.2.0/_static/webpack-macros.html
new file mode 100644
index 0000000..58db785
--- /dev/null
+++ b/0.2.0/_static/webpack-macros.html
@@ -0,0 +1,30 @@
+<!--
+ AUTO-GENERATED from webpack.config.js, do **NOT** edit by hand.
+ These are re-used in layout.html
+-->
+{# Load FontAwesome icons #}
+{% macro head_pre_icons() %}
+ <link href="{{ pathto('_static/vendor/fontawesome/6.1.2/css/all.min.css', 1) }}?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2', 1) }}" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2', 1) }}" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2', 1) }}" />
+{% endmacro %}
+
+{% macro head_pre_assets() %}
+ <!-- Loaded before other Sphinx assets -->
+ <link href="{{ pathto('_static/styles/theme.css', 1) }}?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="{{ pathto('_static/styles/bootstrap.css', 1) }}?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="{{ pathto('_static/styles/pydata-sphinx-theme.css', 1) }}?digest=e353d410970836974a52" rel="stylesheet" />
+{% endmacro %}
+
+{% macro head_js_preload() %}
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="{{ pathto('_static/scripts/bootstrap.js', 1) }}?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="{{ pathto('_static/scripts/pydata-sphinx-theme.js', 1) }}?digest=e353d410970836974a52" />
+{% endmacro %}
+
+{% macro body_post() %}
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="{{ pathto('_static/scripts/bootstrap.js', 1) }}?digest=e353d410970836974a52"></script>
+<script src="{{ pathto('_static/scripts/pydata-sphinx-theme.js', 1) }}?digest=e353d410970836974a52"></script>
+{% endmacro %}
\ No newline at end of file
diff --git a/0.2.0/c.html b/0.2.0/c.html
new file mode 100644
index 0000000..3494642
--- /dev/null
+++ b/0.2.0/c.html
@@ -0,0 +1,2428 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+
+ <title>C API Reference — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'c';</script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="C++ API Reference" href="cpp.html" />
+ <link rel="prev" title="Getting started with nanoarrow" href="getting-started.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="index.html">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+ <div class="navbar-header-items__end">
+
+ <div class="navbar-item navbar-persistent--container">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </nav>
+
+ <div class="bd-container">
+ <div class="bd-container__inner bd-page-width">
+
+ <div class="bd-sidebar-primary bd-sidebar">
+
+
+
+ <div class="sidebar-header-items sidebar-primary__section">
+
+
+ <div class="sidebar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+ <div class="sidebar-primary-items__start sidebar-primary__section">
+ <div class="sidebar-primary-item">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+
+ <div class="sidebar-primary-items__end sidebar-primary__section">
+ </div>
+
+ <div id="rtd-footer-container"></div>
+
+
+ </div>
+
+ <main id="main-content" class="bd-main">
+
+
+ <div class="bd-content">
+ <div class="bd-article-container">
+
+ <div class="bd-header-article">
+<div class="header-article-items header-article__inner">
+
+ <div class="header-article-items__start">
+
+ <div class="header-article-item">
+
+
+
+<nav aria-label="Breadcrumbs">
+ <ul class="bd-breadcrumbs" role="navigation" aria-label="Breadcrumb">
+
+ <li class="breadcrumb-item breadcrumb-home">
+ <a href="index.html" class="nav-link" aria-label="Home">
+ <i class="fa-solid fa-home"></i>
+ </a>
+ </li>
+ <li class="breadcrumb-item active" aria-current="page">C API Reference</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article" role="main">
+
+ <section id="c-api-reference">
+<h1>C API Reference<a class="headerlink" href="#c-api-reference" title="Permalink to this heading">#</a></h1>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow</span></span></dt>
+<dd><p>Except where noted, objects are not thread-safe and clients should take care to serialize accesses to methods.</p>
+<p>Because this library is intended to be vendored, it provides full type definitions and encourages clients to stack or statically allocate where convenient. </p>
+</dd></dl>
+
+<section id="creating-schemas">
+<h2>Creating schemas<a class="headerlink" href="#creating-schemas" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-schema"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-schema</span></span></dt>
+<dd><p>These functions allocate, copy, and destroy <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a> structures </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowSchemaInitP11ArrowSchema">
+<span id="_CPPv315ArrowSchemaInitP11ArrowSchema"></span><span id="_CPPv215ArrowSchemaInitP11ArrowSchema"></span><span id="ArrowSchemaInit__ArrowSchemaP"></span><span class="target" id="group__nanoarrow-schema_1ga4d0f9b69f912b9316ee4201b974d7b6a"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowSchemaInit</span></span></span><span class="sig-paren">(</span><span class="k"><span class= [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+<p>Initializes the fields and release callback of schema_out. Caller is responsible for calling the schema->release callback if NANOARROW_OK is returned. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowSchemaInitFromTypeP11ArrowSchema9ArrowType">
+<span id="_CPPv323ArrowSchemaInitFromTypeP11ArrowSchema9ArrowType"></span><span id="_CPPv223ArrowSchemaInitFromTypeP11ArrowSchema9ArrowType"></span><span id="ArrowSchemaInitFromType__ArrowSchemaP.ArrowType"></span><span class="target" id="group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a> from an ArrowType. </p>
+<p>A convenience constructor for that calls <a class="reference internal" href="#group__nanoarrow-schema_1ga4d0f9b69f912b9316ee4201b974d7b6a"><span class="std std-ref">ArrowSchemaInit()</span></a> and <a class="reference internal" href="#group__nanoarrow-schema_1ga988bcfde77ba9fe310b4f0b649f465d7"><span class="std std-ref">ArrowSchemaSetType()</span></a> for the common case of constructing an unparameterized type. The caller is responsible for calling the schema->release callback if N [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowSchemaToStringP11ArrowSchemaPc7int64_tc">
+<span id="_CPPv319ArrowSchemaToStringP11ArrowSchemaPc7int64_tc"></span><span id="_CPPv219ArrowSchemaToStringP11ArrowSchemaPc7int64_tc"></span><span id="ArrowSchemaToString__ArrowSchemaP.cP.int64_t.c"></span><span class="target" id="group__nanoarrow-schema_1gac04b2acd1d7522377c4d2ea722e8ccf8"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowSchemaToString</span></span></span><span c [...]
+<dd><p>Get a human-readable summary of a Schema. </p>
+<p>Writes a summary of an <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a> to out (up to n - 1 characters) and returns the number of characters required for the output if n were sufficiently large. If recursive is non-zero, the result will also include children. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowSchemaSetTypeP11ArrowSchema9ArrowType">
+<span id="_CPPv318ArrowSchemaSetTypeP11ArrowSchema9ArrowType"></span><span id="_CPPv218ArrowSchemaSetTypeP11ArrowSchema9ArrowType"></span><span id="ArrowSchemaSetType__ArrowSchemaP.ArrowType"></span><span class="target" id="group__nanoarrow-schema_1ga988bcfde77ba9fe310b4f0b649f465d7"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name desc [...]
+<dd><p>Set the format field of a schema from an ArrowType. </p>
+<p>Initializes the fields and release callback of schema_out. For NANOARROW_TYPE_LIST, NANOARROW_TYPE_LARGE_LIST, and NANOARROW_TYPE_MAP, the appropriate number of children are allocated, initialized, and named; however, the caller must <a class="reference internal" href="#group__nanoarrow-schema_1ga988bcfde77ba9fe310b4f0b649f465d7"><span class="std std-ref">ArrowSchemaSetType()</span></a> on the preinitialized children. Schema must have been initialized using <a class="reference interna [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowSchemaSetTypeStructP11ArrowSchema7int64_t">
+<span id="_CPPv324ArrowSchemaSetTypeStructP11ArrowSchema7int64_t"></span><span id="_CPPv224ArrowSchemaSetTypeStructP11ArrowSchema7int64_t"></span><span id="ArrowSchemaSetTypeStruct__ArrowSchemaP.int64_t"></span><span class="target" id="group__nanoarrow-schema_1gac46b4c625d64102870bdf87cf2362ab0"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="s [...]
+<dd><p>Set the format field and initialize children of a struct schema. </p>
+<p>The specified number of children are initialized; however, the caller is responsible for calling <a class="reference internal" href="#group__nanoarrow-schema_1ga988bcfde77ba9fe310b4f0b649f465d7"><span class="std std-ref">ArrowSchemaSetType()</span></a> and <a class="reference internal" href="#group__nanoarrow-schema_1ga8724121ffb964a258577e1fb6038a2ab"><span class="std std-ref">ArrowSchemaSetName()</span></a> on each child. Schema must have been initialized using <a class="reference i [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowSchemaSetTypeFixedSizeP11ArrowSchema9ArrowType7int32_t">
+<span id="_CPPv327ArrowSchemaSetTypeFixedSizeP11ArrowSchema9ArrowType7int32_t"></span><span id="_CPPv227ArrowSchemaSetTypeFixedSizeP11ArrowSchema9ArrowType7int32_t"></span><span id="ArrowSchemaSetTypeFixedSize__ArrowSchemaP.ArrowType.int32_t"></span><span class="target" id="group__nanoarrow-schema_1ga40c84753aaab38b9d2e82221da150801"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a [...]
+<dd><p>Set the format field of a fixed-size schema. </p>
+<p>Returns EINVAL for fixed_size <= 0 or for type that is not NANOARROW_TYPE_FIXED_SIZE_BINARY or NANOARROW_TYPE_FIXED_SIZE_LIST. For NANOARROW_TYPE_FIXED_SIZE_LIST, the appropriate number of children are allocated, initialized, and named; however, the caller must <a class="reference internal" href="#group__nanoarrow-schema_1ga988bcfde77ba9fe310b4f0b649f465d7"><span class="std std-ref">ArrowSchemaSetType()</span></a> the first child. Schema must have been initialized using <a class="r [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv425ArrowSchemaSetTypeDecimalP11ArrowSchema9ArrowType7int32_t7int32_t">
+<span id="_CPPv325ArrowSchemaSetTypeDecimalP11ArrowSchema9ArrowType7int32_t7int32_t"></span><span id="_CPPv225ArrowSchemaSetTypeDecimalP11ArrowSchema9ArrowType7int32_t7int32_t"></span><span id="ArrowSchemaSetTypeDecimal__ArrowSchemaP.ArrowType.int32_t.int32_t"></span><span class="target" id="group__nanoarrow-schema_1gac929a2a27c4b336f31aa3adc6e9a70ee"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCod [...]
+<dd><p>Set the format field of a decimal schema. </p>
+<p>Returns EINVAL for scale <= 0 or for type that is not NANOARROW_TYPE_DECIMAL128 or NANOARROW_TYPE_DECIMAL256. Schema must have been initialized using <a class="reference internal" href="#group__nanoarrow-schema_1ga4d0f9b69f912b9316ee4201b974d7b6a"><span class="std std-ref">ArrowSchemaInit()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"><span class="std std-ref">ArrowSchemaDeepCopy()</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowSchemaSetTypeDateTimeP11ArrowSchema9ArrowType13ArrowTimeUnitPKc">
+<span id="_CPPv326ArrowSchemaSetTypeDateTimeP11ArrowSchema9ArrowType13ArrowTimeUnitPKc"></span><span id="_CPPv226ArrowSchemaSetTypeDateTimeP11ArrowSchema9ArrowType13ArrowTimeUnitPKc"></span><span id="ArrowSchemaSetTypeDateTime__ArrowSchemaP.ArrowType.ArrowTimeUnit.cCP"></span><span class="target" id="group__nanoarrow-schema_1ga1fdb8bec6602d5090f43fa6cde5499d6"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">Arro [...]
+<dd><p>Set the format field of a time, timestamp, or duration schema. </p>
+<p>Returns EINVAL for type that is not NANOARROW_TYPE_TIME32, NANOARROW_TYPE_TIME64, NANOARROW_TYPE_TIMESTAMP, or NANOARROW_TYPE_DURATION. The timezone parameter must be NULL for a non-timestamp type. Schema must have been initialized using <a class="reference internal" href="#group__nanoarrow-schema_1ga4d0f9b69f912b9316ee4201b974d7b6a"><span class="std std-ref">ArrowSchemaInit()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowSchemaSetTypeUnionP11ArrowSchema9ArrowType7int64_t">
+<span id="_CPPv323ArrowSchemaSetTypeUnionP11ArrowSchema9ArrowType7int64_t"></span><span id="_CPPv223ArrowSchemaSetTypeUnionP11ArrowSchema9ArrowType7int64_t"></span><span id="ArrowSchemaSetTypeUnion__ArrowSchemaP.ArrowType.int64_t"></span><span class="target" id="group__nanoarrow-schema_1ga6c6ec7d88e06f263fd0090de4d980ecd"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class [...]
+<dd><p>Seet the format field of a union schema. </p>
+<p>Returns EINVAL for a type that is not NANOARROW_TYPE_DENSE_UNION or NANOARROW_TYPE_SPARSE_UNION. The specified number of children are allocated, and initialized. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowSchemaDeepCopyP11ArrowSchemaP11ArrowSchema">
+<span id="_CPPv319ArrowSchemaDeepCopyP11ArrowSchemaP11ArrowSchema"></span><span id="_CPPv219ArrowSchemaDeepCopyP11ArrowSchemaP11ArrowSchema"></span><span id="ArrowSchemaDeepCopy__ArrowSchemaP.ArrowSchemaP"></span><span class="target" id="group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class= [...]
+<dd><p>Make a (recursive) copy of a schema. </p>
+<p>Allocates and copies fields of schema into schema_out. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowSchemaSetFormatP11ArrowSchemaPKc">
+<span id="_CPPv320ArrowSchemaSetFormatP11ArrowSchemaPKc"></span><span id="_CPPv220ArrowSchemaSetFormatP11ArrowSchemaPKc"></span><span id="ArrowSchemaSetFormat__ArrowSchemaP.cCP"></span><span class="target" id="group__nanoarrow-schema_1ga8eb8a8a73a189ea2f9eabdc237adbf84"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname"><span cl [...]
+<dd><p>Copy format into schema->format. </p>
+<p>schema must have been allocated using <a class="reference internal" href="#group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"><span class="std std-ref">ArrowSchemaInitFromType()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"><span class="std std-ref">ArrowSchemaDeepCopy()</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowSchemaSetNameP11ArrowSchemaPKc">
+<span id="_CPPv318ArrowSchemaSetNameP11ArrowSchemaPKc"></span><span id="_CPPv218ArrowSchemaSetNameP11ArrowSchemaPKc"></span><span id="ArrowSchemaSetName__ArrowSchemaP.cCP"></span><span class="target" id="group__nanoarrow-schema_1ga8724121ffb964a258577e1fb6038a2ab"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname"><span class="n [...]
+<dd><p>Copy name into schema->name. </p>
+<p>schema must have been allocated using <a class="reference internal" href="#group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"><span class="std std-ref">ArrowSchemaInitFromType()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"><span class="std std-ref">ArrowSchemaDeepCopy()</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowSchemaSetMetadataP11ArrowSchemaPKc">
+<span id="_CPPv322ArrowSchemaSetMetadataP11ArrowSchemaPKc"></span><span id="_CPPv222ArrowSchemaSetMetadataP11ArrowSchemaPKc"></span><span id="ArrowSchemaSetMetadata__ArrowSchemaP.cCP"></span><span class="target" id="group__nanoarrow-schema_1ga3755dcc5bdbc9c850a5576ea74713c2b"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname"><s [...]
+<dd><p>Copy metadata into schema->metadata. </p>
+<p>schema must have been allocated using <a class="reference internal" href="#group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"><span class="std std-ref">ArrowSchemaInitFromType()</span></a> or ArrowSchemaDeepCopy. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowSchemaAllocateChildrenP11ArrowSchema7int64_t">
+<span id="_CPPv327ArrowSchemaAllocateChildrenP11ArrowSchema7int64_t"></span><span id="_CPPv227ArrowSchemaAllocateChildrenP11ArrowSchema7int64_t"></span><span id="ArrowSchemaAllocateChildren__ArrowSchemaP.int64_t"></span><span class="target" id="group__nanoarrow-schema_1gabdbe36e6bdca89a4a8c3e11c6bb4660e"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span [...]
+<dd><p>Allocate the schema->children array. </p>
+<p>Includes the memory for each child struct <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. schema must have been allocated using <a class="reference internal" href="#group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"><span class="std std-ref">ArrowSchemaInitFromType()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"><span class="std std-ref">ArrowSchemaDe [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv429ArrowSchemaAllocateDictionaryP11ArrowSchema">
+<span id="_CPPv329ArrowSchemaAllocateDictionaryP11ArrowSchema"></span><span id="_CPPv229ArrowSchemaAllocateDictionaryP11ArrowSchema"></span><span id="ArrowSchemaAllocateDictionary__ArrowSchemaP"></span><span class="target" id="group__nanoarrow-schema_1ga7c2cc4b5fec3950a9d6cebda6af279da"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name d [...]
+<dd><p>Allocate the schema->dictionary member. </p>
+<p>schema must have been allocated using <a class="reference internal" href="#group__nanoarrow-schema_1ga58b44e1513d1d754bfa7bf313ffac66f"><span class="std std-ref">ArrowSchemaInitFromType()</span></a> or <a class="reference internal" href="#group__nanoarrow-schema_1gaa6c710253f812d5d5f3663c204468af4"><span class="std std-ref">ArrowSchemaDeepCopy()</span></a>. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</section>
+<section id="reading-schemas">
+<h2>Reading schemas<a class="headerlink" href="#reading-schemas" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-schema-view"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-schema-view</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowSchemaViewInitP15ArrowSchemaViewP11ArrowSchemaP10ArrowError">
+<span id="_CPPv319ArrowSchemaViewInitP15ArrowSchemaViewP11ArrowSchemaP10ArrowError"></span><span id="_CPPv219ArrowSchemaViewInitP15ArrowSchemaViewP11ArrowSchemaP10ArrowError"></span><span id="ArrowSchemaViewInit__ArrowSchemaViewP.ArrowSchemaP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-schema-view_1ga3e14b8d831ace92286c476206ba00ca1"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCod [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_schema_view"><span class="std std-ref">ArrowSchemaView</span></a>. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowSchemaView">
+<span id="_CPPv315ArrowSchemaView"></span><span id="_CPPv215ArrowSchemaView"></span><span id="ArrowSchemaView"></span><span class="target" id="struct_arrow_schema_view"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowSchemaView</span></span></span><a class="headerlink" href="#_CPPv415ArrowSchemaView" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow.h></em></div>
+<p>A non-owning view of a parsed <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+<p>Contains more readily extractable values than a raw <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. Clients can stack or statically allocate this structure but are encouraged to use the provided getters to ensure forward compatiblity. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView6schemaE">
+<span id="_CPPv3N15ArrowSchemaView6schemaE"></span><span id="_CPPv2N15ArrowSchemaView6schemaE"></span><span id="ArrowSchemaView::schema__ArrowSchemaP"></span><span class="target" id="struct_arrow_schema_view_1a57cab09d0c332eaf55d4886d600ecd6a"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowSchema" title="ArrowSchema"><span class="n"><span class="pre">ArrowSchema</span></span></a><span class="w"> </spa [...]
+<dd><p>A pointer to the schema represented by this view. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView4typeE">
+<span id="_CPPv3N15ArrowSchemaView4typeE"></span><span id="_CPPv2N15ArrowSchemaView4typeE"></span><span id="ArrowSchemaView::type__ArrowType"></span><span class="target" id="struct_arrow_schema_view_1a1f51e34d323d40a26b9c290307cda86a"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv49ArrowType" title="ArrowType"><span class="n"><span class="pre">ArrowType</span></span></a><span class="w"> </span><span class="sig [...]
+<dd><p>The data type represented by the schema. </p>
+<p>This value may be NANOARROW_TYPE_DICTIONARY if the schema has a non-null dictionary member; datetime types are valid values. This value will never be NANOARROW_TYPE_EXTENSION (see extension_name and/or extension_metadata to check for an extension type). </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView12storage_typeE">
+<span id="_CPPv3N15ArrowSchemaView12storage_typeE"></span><span id="_CPPv2N15ArrowSchemaView12storage_typeE"></span><span id="ArrowSchemaView::storage_type__ArrowType"></span><span class="target" id="struct_arrow_schema_view_1ad51571638c8fc6cdbbc84135be4ca8eb"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv49ArrowType" title="ArrowType"><span class="n"><span class="pre">ArrowType</span></span></a><span class="w [...]
+<dd><p>The storage data type represented by the schema. </p>
+<p>This value will never be NANOARROW_TYPE_DICTIONARY, NANOARROW_TYPE_EXTENSION or any datetime type. This value represents only the type required to interpret the buffers in the array. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView6layoutE">
+<span id="_CPPv3N15ArrowSchemaView6layoutE"></span><span id="_CPPv2N15ArrowSchemaView6layoutE"></span><span id="ArrowSchemaView::layout__ArrowLayout"></span><span class="target" id="struct_arrow_schema_view_1ada30de73dfb00c14bf9d9d14ad38d327"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowLayout" title="ArrowLayout"><span class="n"><span class="pre">ArrowLayout</span></span></a><span class="w"> </span [...]
+<dd><p>The storage layout represented by the schema. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView14extension_nameE">
+<span id="_CPPv3N15ArrowSchemaView14extension_nameE"></span><span id="_CPPv2N15ArrowSchemaView14extension_nameE"></span><span id="ArrowSchemaView::extension_name__ArrowStringView"></span><span class="target" id="struct_arrow_schema_view_1a0d085aea742e822502485445e580dea2"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv415ArrowStringView" title="ArrowStringView"><span class="n"><span class="pre">ArrowStringVie [...]
+<dd><p>The extension type name if it exists. </p>
+<p>If the ARROW:extension:name key is present in schema.metadata, extension_name.data will be non-NULL. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView18extension_metadataE">
+<span id="_CPPv3N15ArrowSchemaView18extension_metadataE"></span><span id="_CPPv2N15ArrowSchemaView18extension_metadataE"></span><span id="ArrowSchemaView::extension_metadata__ArrowStringView"></span><span class="target" id="struct_arrow_schema_view_1afb68ff6039541facdc3afb61c9acd558"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv415ArrowStringView" title="ArrowStringView"><span class="n"><span class="pre">Ar [...]
+<dd><p>The extension type metadata if it exists. </p>
+<p>If the ARROW:extension:metadata key is present in schema.metadata, extension_metadata.data will be non-NULL. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView10fixed_sizeE">
+<span id="_CPPv3N15ArrowSchemaView10fixed_sizeE"></span><span id="_CPPv2N15ArrowSchemaView10fixed_sizeE"></span><span id="ArrowSchemaView::fixed_size__int32_t"></span><span class="target" id="struct_arrow_schema_view_1ab74f333f4ab5889a4d5b6352a9e8acd9"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">fixed_size</span></span></span><a class="headerlink" href="#_CPPv4N15ArrowSchemaView10f [...]
+<dd><p>Format fixed size parameter. </p>
+<p>This value is set when parsing a fixed-size binary or fixed-size list schema; this value is undefined for other types. For a fixed-size binary schema this value is in bytes; for a fixed-size list schema this value refers to the number of child elements for each element of the parent. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView16decimal_bitwidthE">
+<span id="_CPPv3N15ArrowSchemaView16decimal_bitwidthE"></span><span id="_CPPv2N15ArrowSchemaView16decimal_bitwidthE"></span><span id="ArrowSchemaView::decimal_bitwidth__int32_t"></span><span class="target" id="struct_arrow_schema_view_1a7d632b171c76ca184d4a50f144dd16a0"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">decimal_bitwidth</span></span></span><a class="headerlink" href="#_CP [...]
+<dd><p>Decimal bitwidth. </p>
+<p>This value is set when parsing a decimal type schema; this value is undefined for other types. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView17decimal_precisionE">
+<span id="_CPPv3N15ArrowSchemaView17decimal_precisionE"></span><span id="_CPPv2N15ArrowSchemaView17decimal_precisionE"></span><span id="ArrowSchemaView::decimal_precision__int32_t"></span><span class="target" id="struct_arrow_schema_view_1a1cc325480d15c9823e6860b4caacb697"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">decimal_precision</span></span></span><a class="headerlink" href=" [...]
+<dd><p>Decimal precision. </p>
+<p>This value is set when parsing a decimal type schema; this value is undefined for other types. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView13decimal_scaleE">
+<span id="_CPPv3N15ArrowSchemaView13decimal_scaleE"></span><span id="_CPPv2N15ArrowSchemaView13decimal_scaleE"></span><span id="ArrowSchemaView::decimal_scale__int32_t"></span><span class="target" id="struct_arrow_schema_view_1a138e714b344e2bd3b5d1427ca38221aa"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">decimal_scale</span></span></span><a class="headerlink" href="#_CPPv4N15ArrowS [...]
+<dd><p>Decimal scale. </p>
+<p>This value is set when parsing a decimal type schema; this value is undefined for other types. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView9time_unitE">
+<span id="_CPPv3N15ArrowSchemaView9time_unitE"></span><span id="_CPPv2N15ArrowSchemaView9time_unitE"></span><span id="ArrowSchemaView::time_unit__ArrowTimeUnit"></span><span class="target" id="struct_arrow_schema_view_1a51df746b957ea34af6128a111bd5e43e"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv413ArrowTimeUnit" title="ArrowTimeUnit"><span class="n"><span class="pre">ArrowTimeUnit</span></span></a><span cl [...]
+<dd><p>Format time unit parameter. </p>
+<p>This value is set when parsing a date/time type. The value is undefined for other types. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView8timezoneE">
+<span id="_CPPv3N15ArrowSchemaView8timezoneE"></span><span id="_CPPv2N15ArrowSchemaView8timezoneE"></span><span id="ArrowSchemaView::timezone__cCP"></span><span class="target" id="struct_arrow_schema_view_1acc840f35c2148a1fc51ee66bebf3ef71"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span cla [...]
+<dd><p>Format timezone parameter. </p>
+<p>This value is set when parsing a timestamp type and represents the timezone format parameter. This value points to data within the schema and is undefined for other types. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowSchemaView14union_type_idsE">
+<span id="_CPPv3N15ArrowSchemaView14union_type_idsE"></span><span id="_CPPv2N15ArrowSchemaView14union_type_idsE"></span><span id="ArrowSchemaView::union_type_ids__cCP"></span><span class="target" id="struct_arrow_schema_view_1a9f60c668660bc392308e625e3bf47778"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name [...]
+<dd><p>Union type ids parameter. </p>
+<p>This value is set when parsing a union type and represents type ids parameter. This value points to data within the schema and is undefined for other types. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="creating-arrays">
+<h2>Creating arrays<a class="headerlink" href="#creating-arrays" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-array"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-array</span></span></dt>
+<dd><p>These functions allocate, copy, and destroy <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> structures. Once an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> has been initialized via <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a> or <a class="reference inte [...]
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-enums">Enums</p>
+<dl class="cpp enum">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowValidationLevel">
+<span id="_CPPv320ArrowValidationLevel"></span><span id="_CPPv220ArrowValidationLevel"></span><span class="target" id="group__nanoarrow-array_1ga75bb85a49c08c4ce1e60876d3973c4ab"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowValidationLevel</span></span></span><a class="headerlink" href="#_CPPv420ArrowValidationLevel" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Validation level enumerator. </p>
+<p><em>Values:</em></p>
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_NONEE">
+<span id="_CPPv3N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_NONEE"></span><span id="_CPPv2N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_NONEE"></span><span class="target" id="group__nanoarrow-array_1gga75bb85a49c08c4ce1e60876d3973c4aba151d32847475d1e1a261ab6565559307"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_VALIDATION_LEVEL_NONE</span></span></span><a [...]
+<dd><p>Do not validate buffer sizes or content. </p>
+</dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_MINIMALE">
+<span id="_CPPv3N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_MINIMALE"></span><span id="_CPPv2N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_MINIMALE"></span><span class="target" id="group__nanoarrow-array_1gga75bb85a49c08c4ce1e60876d3973c4aba41624e0991614eaf78e05b4ae9cd9891"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_VALIDATION_LEVEL_MINIMAL</span></span> [...]
+<dd><p>Validate buffer sizes that depend on array length but do not validate buffer sizes that depend on buffer data access. </p>
+</dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_DEFAULTE">
+<span id="_CPPv3N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_DEFAULTE"></span><span id="_CPPv2N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_DEFAULTE"></span><span class="target" id="group__nanoarrow-array_1gga75bb85a49c08c4ce1e60876d3973c4aba6b31654cb4568bc0f77365853b9ab154"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_VALIDATION_LEVEL_DEFAULT</span></span> [...]
+<dd><p>Validate all buffer sizes, including those that require buffer data access, but do not perform any checks that are O(1) along the length of the buffers. </p>
+</dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_FULLE">
+<span id="_CPPv3N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_FULLE"></span><span id="_CPPv2N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_FULLE"></span><span class="target" id="group__nanoarrow-array_1gga75bb85a49c08c4ce1e60876d3973c4aba9475a854f102de99e9a8f3a22eb66226"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_VALIDATION_LEVEL_FULL</span></span></span><a [...]
+<dd><p>Validate all buffer sizes and all buffer content. This is useful in the context of untrusted input or input that may have been corrupted in transit. </p>
+</dd></dl>
+
+</dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowArrayInitFromTypeP10ArrowArray9ArrowType">
+<span id="_CPPv322ArrowArrayInitFromTypeP10ArrowArray9ArrowType"></span><span id="_CPPv222ArrowArrayInitFromTypeP10ArrowArray9ArrowType"></span><span id="ArrowArrayInitFromType__ArrowArrayP.ArrowType"></span><span class="target" id="group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-n [...]
+<dd><p>Initialize the fields of an array. </p>
+<p>Initializes the fields and release callback of array. Caller is responsible for calling the array->release callback if NANOARROW_OK is returned. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowArrayInitFromSchemaP10ArrowArrayP11ArrowSchemaP10ArrowError">
+<span id="_CPPv324ArrowArrayInitFromSchemaP10ArrowArrayP11ArrowSchemaP10ArrowError"></span><span id="_CPPv224ArrowArrayInitFromSchemaP10ArrowArrayP11ArrowSchemaP10ArrowError"></span><span id="ArrowArrayInitFromSchema__ArrowArrayP.ArrowSchemaP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array_1ga31a82c7fe72e5cc46eeab4713c284f84"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</spa [...]
+<dd><p>Initialize the contents of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> from an <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+<p>Caller is responsible for calling the array->release callback if NANOARROW_OK is returned. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowArrayInitFromArrayViewP10ArrowArrayP14ArrowArrayViewP10ArrowError">
+<span id="_CPPv327ArrowArrayInitFromArrayViewP10ArrowArrayP14ArrowArrayViewP10ArrowError"></span><span id="_CPPv227ArrowArrayInitFromArrayViewP10ArrowArrayP14ArrowArrayViewP10ArrowError"></span><span id="ArrowArrayInitFromArrayView__ArrowArrayP.ArrowArrayViewP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array_1ga2014ebcd846b15b8f7a946bddaf9988c"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">A [...]
+<dd><p>Initialize the contents of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> from an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+<p>Caller is responsible for calling the array->release callback if NANOARROW_OK is returned. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowArrayAllocateChildrenP10ArrowArray7int64_t">
+<span id="_CPPv326ArrowArrayAllocateChildrenP10ArrowArray7int64_t"></span><span id="_CPPv226ArrowArrayAllocateChildrenP10ArrowArray7int64_t"></span><span id="ArrowArrayAllocateChildren__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1ga2efc2f2831aabd24e3a894959206b770"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class= [...]
+<dd><p>Allocate the array->children array. </p>
+<p>Includes the memory for each child struct <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>, whose members are marked as released and may be subsequently initialized with <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a> or moved from an existing <a class="reference internal" href="#struct_arrow_array"><span class="std std- [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv428ArrowArrayAllocateDictionaryP10ArrowArray">
+<span id="_CPPv328ArrowArrayAllocateDictionaryP10ArrowArray"></span><span id="_CPPv228ArrowArrayAllocateDictionaryP10ArrowArray"></span><span id="ArrowArrayAllocateDictionary__ArrowArrayP"></span><span class="target" id="group__nanoarrow-array_1ga0bfe9d4cddb8de65e29ab46ce0b495a4"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname [...]
+<dd><p>Allocate the array->dictionary member. </p>
+<p>Includes the memory for the struct <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>, whose contents is marked as released and may be subsequently initialized with <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a> or moved from an existing <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">Ar [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowArraySetValidityBitmapP10ArrowArrayP11ArrowBitmap">
+<span id="_CPPv327ArrowArraySetValidityBitmapP10ArrowArrayP11ArrowBitmap"></span><span id="_CPPv227ArrowArraySetValidityBitmapP10ArrowArrayP11ArrowBitmap"></span><span id="ArrowArraySetValidityBitmap__ArrowArrayP.ArrowBitmapP"></span><span class="target" id="group__nanoarrow-array_1gad8aef62893226fa4764a9c63eb602080"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArraySetValidityBi [...]
+<dd><p>Set the validity bitmap of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowArraySetBufferP10ArrowArray7int64_tP11ArrowBuffer">
+<span id="_CPPv319ArrowArraySetBufferP10ArrowArray7int64_tP11ArrowBuffer"></span><span id="_CPPv219ArrowArraySetBufferP10ArrowArray7int64_tP11ArrowBuffer"></span><span id="ArrowArraySetBuffer__ArrowArrayP.int64_t.ArrowBufferP"></span><span class="target" id="group__nanoarrow-array_1ga52111316e373e24687710f5158da3527"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> [...]
+<dd><p>Set a buffer of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowArrayValidityBitmapP10ArrowArray">
+<span id="_CPPv324ArrowArrayValidityBitmapP10ArrowArray"></span><span id="_CPPv224ArrowArrayValidityBitmapP10ArrowArray"></span><span id="ArrowArrayValidityBitmap__ArrowArrayP"></span><span class="target" id="group__nanoarrow-array_1ga3e0fdea696cd9afabd3eb2a59ea95375"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span [...]
+<dd><p>Get the validity bitmap of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowArrayBufferP10ArrowArray7int64_t">
+<span id="_CPPv316ArrowArrayBufferP10ArrowArray7int64_t"></span><span id="_CPPv216ArrowArrayBufferP10ArrowArray7int64_t"></span><span id="ArrowArrayBuffer__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1gafbd17d94c188c9760f5bc91195683bd8"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span [...]
+<dd><p>Get a buffer of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowArrayStartAppendingP10ArrowArray">
+<span id="_CPPv324ArrowArrayStartAppendingP10ArrowArray"></span><span id="_CPPv224ArrowArrayStartAppendingP10ArrowArray"></span><span id="ArrowArrayStartAppending__ArrowArrayP"></span><span class="target" id="group__nanoarrow-array_1gaab61ae0a0eb698c817bee25ee3a750f5"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowErrorCode" [...]
+<dd><p>Start element-wise appending to an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>Initializes any values needed to use ArrowArrayAppend*() functions. All element-wise appenders append by value and return EINVAL if the exact value cannot be represented by the underlying storage type. array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowArrayReserveP10ArrowArray7int64_t">
+<span id="_CPPv317ArrowArrayReserveP10ArrowArray7int64_t"></span><span id="_CPPv217ArrowArrayReserveP10ArrowArray7int64_t"></span><span id="ArrowArrayReserve__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1gaa2644de6315ff68a694370c51948071e"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname"><span c [...]
+<dd><p>Reserve space for future appends. </p>
+<p>For buffer sizes that can be calculated (i.e., not string data buffers or child array sizes for non-fixed-size arrays), recursively reserve space for additional elements. This is useful for reducing the number of reallocations that occur using the item-wise appenders. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowArrayAppendNullP10ArrowArray7int64_t">
+<span id="_CPPv320ArrowArrayAppendNullP10ArrowArray7int64_t"></span><span id="_CPPv220ArrowArrayAppendNullP10ArrowArray7int64_t"></span><span id="ArrowArrayAppendNull__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1ga7b4c3eb74f4bc6c6155599fb2658f927"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arr [...]
+<dd><p>Append a null value to an array. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowArrayAppendEmptyP10ArrowArray7int64_t">
+<span id="_CPPv321ArrowArrayAppendEmptyP10ArrowArray7int64_t"></span><span id="_CPPv221ArrowArrayAppendEmptyP10ArrowArray7int64_t"></span><span id="ArrowArrayAppendEmpty__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1ga5b1a001a5ed966662a5c48bdc5f48ce6"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414 [...]
+<dd><p>Append an empty, non-null value to an array. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowArrayAppendIntP10ArrowArray7int64_t">
+<span id="_CPPv319ArrowArrayAppendIntP10ArrowArray7int64_t"></span><span id="_CPPv219ArrowArrayAppendIntP10ArrowArray7int64_t"></span><span id="ArrowArrayAppendInt__ArrowArrayP.int64_t"></span><span class="target" id="group__nanoarrow-array_1gac6b99a2b05db4c956def99131f803994"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowE [...]
+<dd><p>Append a signed integer value to an array. </p>
+<p>Returns NANOARROW_OK if value can be exactly represented by the underlying storage type or EINVAL otherwise (e.g., value is outside the valid array range). </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowArrayAppendUIntP10ArrowArray8uint64_t">
+<span id="_CPPv320ArrowArrayAppendUIntP10ArrowArray8uint64_t"></span><span id="_CPPv220ArrowArrayAppendUIntP10ArrowArray8uint64_t"></span><span id="ArrowArrayAppendUInt__ArrowArrayP.uint64_t"></span><span class="target" id="group__nanoarrow-array_1gae91f4c278859a8457b8090ca4dfd1e31"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414 [...]
+<dd><p>Append an unsigned integer value to an array. </p>
+<p>Returns NANOARROW_OK if value can be exactly represented by the underlying storage type or EINVAL otherwise (e.g., value is outside the valid array range). </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowArrayAppendDoubleP10ArrowArrayd">
+<span id="_CPPv322ArrowArrayAppendDoubleP10ArrowArrayd"></span><span id="_CPPv222ArrowArrayAppendDoubleP10ArrowArrayd"></span><span id="ArrowArrayAppendDouble__ArrowArrayP.double"></span><span class="target" id="group__nanoarrow-array_1ga2e03258b386ed299928471394586b185"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowErrorCo [...]
+<dd><p>Append a double value to an array. </p>
+<p>Returns NANOARROW_OK if value can be exactly represented by the underlying storage type or EINVAL otherwise (e.g., value is outside the valid array range or there is an attempt to append a non-integer to an array with an integer storage type). </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowArrayAppendBytesP10ArrowArray15ArrowBufferView">
+<span id="_CPPv321ArrowArrayAppendBytesP10ArrowArray15ArrowBufferView"></span><span id="_CPPv221ArrowArrayAppendBytesP10ArrowArray15ArrowBufferView"></span><span id="ArrowArrayAppendBytes__ArrowArrayP.ArrowBufferView"></span><span class="target" id="group__nanoarrow-array_1ga40e1dce8b43124c9710538842e68f944"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference [...]
+<dd><p>Append a string of bytes to an array. </p>
+<p>Returns NANOARROW_OK if value can be exactly represented by the underlying storage type or EINVAL otherwise (e.g., the underlying array is not a binary, string, large binary, large string, or fixed-size binary array, or value is the wrong size for a fixed-size binary array). </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowArrayAppendStringP10ArrowArray15ArrowStringView">
+<span id="_CPPv322ArrowArrayAppendStringP10ArrowArray15ArrowStringView"></span><span id="_CPPv222ArrowArrayAppendStringP10ArrowArray15ArrowStringView"></span><span id="ArrowArrayAppendString__ArrowArrayP.ArrowStringView"></span><span class="target" id="group__nanoarrow-array_1gaa8c9118312eda7fc17fb6bf9d721ca9d"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="refere [...]
+<dd><p>Append a string value to an array. </p>
+<p>Returns NANOARROW_OK if value can be exactly represented by the underlying storage type or EINVAL otherwise (e.g., the underlying array is not a string or large string array). </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowArrayAppendDecimalP10ArrowArrayP12ArrowDecimal">
+<span id="_CPPv323ArrowArrayAppendDecimalP10ArrowArrayP12ArrowDecimal"></span><span id="_CPPv223ArrowArrayAppendDecimalP10ArrowArrayP12ArrowDecimal"></span><span id="ArrowArrayAppendDecimal__ArrowArrayP.ArrowDecimalP"></span><span class="target" id="group__nanoarrow-array_1gaa224decd739a8941991588cb94860386"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference [...]
+<dd><p>Append a decimal value to an array. </p>
+<p>Returns NANOARROW_OK if array is a decimal array with the appropriate bitwidth or EINVAL otherwise. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowArrayFinishElementP10ArrowArray">
+<span id="_CPPv323ArrowArrayFinishElementP10ArrowArray"></span><span id="_CPPv223ArrowArrayFinishElementP10ArrowArray"></span><span id="ArrowArrayFinishElement__ArrowArrayP"></span><span class="target" id="group__nanoarrow-array_1ga357c8828c0ae590c5ae26eac22cce485"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowErrorCode" ti [...]
+<dd><p>Finish a nested array element. </p>
+<p>Appends a non-null element to the array based on the first child’s current length. Returns NANOARROW_OK if the item was successfully added or EINVAL if the underlying storage type is not a struct, list, large list, or fixed-size list, or if there was an attempt to add a struct or fixed-size list element where the length of the child array(s) did not match the expected length. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv428ArrowArrayFinishUnionElementP10ArrowArray6int8_t">
+<span id="_CPPv328ArrowArrayFinishUnionElementP10ArrowArray6int8_t"></span><span id="_CPPv228ArrowArrayFinishUnionElementP10ArrowArray6int8_t"></span><span id="ArrowArrayFinishUnionElement__ArrowArrayP.int8_t"></span><span class="target" id="group__nanoarrow-array_1ga5034d76e216e4ace59813f6232a587d2"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference interna [...]
+<dd><p>Finish a union array element. </p>
+<p>Appends an element to the union type ids buffer and increments array->length. For sparse unions, up to one element is added to non type-id children. Returns EINVAL if the underlying storage type is not a union, if type_id is not valid, or if child sizes after appending are inconsistent. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowArrayShrinkToFitP10ArrowArray">
+<span id="_CPPv321ArrowArrayShrinkToFitP10ArrowArray"></span><span id="_CPPv221ArrowArrayShrinkToFitP10ArrowArray"></span><span id="ArrowArrayShrinkToFit__ArrowArrayP"></span><span class="target" id="group__nanoarrow-array_1gaa6e5c94f307218fcc22578cacf07cf81"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="A [...]
+<dd><p>Shrink buffer capacity to the size required. </p>
+<p>Also applies shrinking to any child arrays. array must have been allocated using ArrowArrayInitFromType </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv431ArrowArrayFinishBuildingDefaultP10ArrowArrayP10ArrowError">
+<span id="_CPPv331ArrowArrayFinishBuildingDefaultP10ArrowArrayP10ArrowError"></span><span id="_CPPv231ArrowArrayFinishBuildingDefaultP10ArrowArrayP10ArrowError"></span><span id="ArrowArrayFinishBuildingDefault__ArrowArrayP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array_1ga53e9821a54550269d34e4f72126c23b9"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span c [...]
+<dd><p>Finish building an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>Flushes any pointers from internal buffers that may have been reallocated into array->buffers and checks the actual size of the buffers against the expected size based on the final length. array must have been allocated using <a class="reference internal" href="#group__nanoarrow-array_1ga7ba21750febf031b1506fa5f391d9074"><span class="std std-ref">ArrowArrayInitFromType()</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowArrayFinishBuildingP10ArrowArray20ArrowValidationLevelP10ArrowError">
+<span id="_CPPv324ArrowArrayFinishBuildingP10ArrowArray20ArrowValidationLevelP10ArrowError"></span><span id="_CPPv224ArrowArrayFinishBuildingP10ArrowArray20ArrowValidationLevelP10ArrowError"></span><span id="ArrowArrayFinishBuilding__ArrowArrayP.ArrowValidationLevel.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array_1ga4b943650875e4d3c44731d98059e9238"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class=" [...]
+<dd><p>Finish building an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> with explicit validation. </p>
+<p>Finish building with an explicit validation level. This could perform less validation (i.e. NANOARROW_VALIDATION_LEVEL_NONE or NANOARROW_VALIDATION_LEVEL_MINIMAL) if CPU buffer data access is not possible or more validation (i.e., NANOARROW_VALIDATION_LEVEL_FULL) if buffer content was obtained from an untrusted or corruptable source. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</section>
+<section id="reading-arrays">
+<h2>Reading arrays<a class="headerlink" href="#reading-arrays" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-array-view"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-array-view</span></span></dt>
+<dd><p>These functions read and validate the contents <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> structures. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-enums">Enums</p>
+<dl class="cpp enum">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBufferType">
+<span id="_CPPv315ArrowBufferType"></span><span id="_CPPv215ArrowBufferType"></span><span class="target" id="group__nanoarrow-array-view_1gafb87c2db710e94139307b34327b23aeb"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowBufferType</span></span></span><a class="headerlink" href="#_CPPv415ArrowBufferType" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Functional types of buffers as described in the Arrow Columnar Specification. </p>
+<p><em>Values:</em></p>
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_NONEE">
+<span id="_CPPv3N15ArrowBufferType26NANOARROW_BUFFER_TYPE_NONEE"></span><span id="_CPPv2N15ArrowBufferType26NANOARROW_BUFFER_TYPE_NONEE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aebaca8312fb6c00d70740a085b24b7e3a01"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_NONE</span></span></span><a class="headerlink" [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType30NANOARROW_BUFFER_TYPE_VALIDITYE">
+<span id="_CPPv3N15ArrowBufferType30NANOARROW_BUFFER_TYPE_VALIDITYE"></span><span id="_CPPv2N15ArrowBufferType30NANOARROW_BUFFER_TYPE_VALIDITYE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aebaf5a1f4c316e22d84f8a81009e9a3c03a"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_VALIDITY</span></span></span><a class=" [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType29NANOARROW_BUFFER_TYPE_TYPE_IDE">
+<span id="_CPPv3N15ArrowBufferType29NANOARROW_BUFFER_TYPE_TYPE_IDE"></span><span id="_CPPv2N15ArrowBufferType29NANOARROW_BUFFER_TYPE_TYPE_IDE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aeba77879a1a9be649147492446ada5c9c71"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_TYPE_ID</span></span></span><a class="hea [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType34NANOARROW_BUFFER_TYPE_UNION_OFFSETE">
+<span id="_CPPv3N15ArrowBufferType34NANOARROW_BUFFER_TYPE_UNION_OFFSETE"></span><span id="_CPPv2N15ArrowBufferType34NANOARROW_BUFFER_TYPE_UNION_OFFSETE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aeba25de4c0c59ab021677748c3f95530a51"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_UNION_OFFSET</span></span></spa [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType33NANOARROW_BUFFER_TYPE_DATA_OFFSETE">
+<span id="_CPPv3N15ArrowBufferType33NANOARROW_BUFFER_TYPE_DATA_OFFSETE"></span><span id="_CPPv2N15ArrowBufferType33NANOARROW_BUFFER_TYPE_DATA_OFFSETE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aeba533f17b74b2778687154fd2a52cb2e34"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_DATA_OFFSET</span></span></span>< [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_DATAE">
+<span id="_CPPv3N15ArrowBufferType26NANOARROW_BUFFER_TYPE_DATAE"></span><span id="_CPPv2N15ArrowBufferType26NANOARROW_BUFFER_TYPE_DATAE"></span><span class="target" id="group__nanoarrow-array-view_1ggafb87c2db710e94139307b34327b23aeba04fce1bd1cd2dec4c43d6820abade32c"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_BUFFER_TYPE_DATA</span></span></span><a class="headerlink" [...]
+<dd></dd></dl>
+
+</dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowArrayViewInitFromTypeP14ArrowArrayView9ArrowType">
+<span id="_CPPv326ArrowArrayViewInitFromTypeP14ArrowArrayView9ArrowType"></span><span id="_CPPv226ArrowArrayViewInitFromTypeP14ArrowArrayView9ArrowType"></span><span id="ArrowArrayViewInitFromType__ArrowArrayViewP.ArrowType"></span><span class="target" id="group__nanoarrow-array-view_1ga93d04cfb41967e576d17f29281991b6b"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArrayViewInitFr [...]
+<dd><p>Initialize the contents of an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowArrayViewMoveP14ArrowArrayViewP14ArrowArrayView">
+<span id="_CPPv318ArrowArrayViewMoveP14ArrowArrayViewP14ArrowArrayView"></span><span id="_CPPv218ArrowArrayViewMoveP14ArrowArrayViewP14ArrowArrayView"></span><span id="ArrowArrayViewMove__ArrowArrayViewP.ArrowArrayViewP"></span><span class="target" id="group__nanoarrow-array-view_1ga1d0b313a8cdb5c58f548812bff4720f1"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class [...]
+<dd><p>Move an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+<p>Transfers the <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> data and lifecycle management to another address and resets the contents of src. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv428ArrowArrayViewInitFromSchemaP14ArrowArrayViewP11ArrowSchemaP10ArrowError">
+<span id="_CPPv328ArrowArrayViewInitFromSchemaP14ArrowArrayViewP11ArrowSchemaP10ArrowError"></span><span id="_CPPv228ArrowArrayViewInitFromSchemaP14ArrowArrayViewP11ArrowSchemaP10ArrowError"></span><span id="ArrowArrayViewInitFromSchema__ArrowArrayViewP.ArrowSchemaP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array-view_1gaaba0e72bc11b0696fef0260d1ecd554f"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span cl [...]
+<dd><p>Initialize the contents of an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> from an <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv430ArrowArrayViewAllocateChildrenP14ArrowArrayView7int64_t">
+<span id="_CPPv330ArrowArrayViewAllocateChildrenP14ArrowArrayView7int64_t"></span><span id="_CPPv230ArrowArrayViewAllocateChildrenP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewAllocateChildren__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga62b297db8007ff76852958f7d6301e8f"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span c [...]
+<dd><p>Allocate the array_view->children array. </p>
+<p>Includes the memory for each child struct <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a></p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv432ArrowArrayViewAllocateDictionaryP14ArrowArrayView">
+<span id="_CPPv332ArrowArrayViewAllocateDictionaryP14ArrowArrayView"></span><span id="_CPPv232ArrowArrayViewAllocateDictionaryP14ArrowArrayView"></span><span id="ArrowArrayViewAllocateDictionary__ArrowArrayViewP"></span><span class="target" id="group__nanoarrow-array-view_1ga55ed8d73a3d140a05ceb69bc5eb9ce2e"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span>< [...]
+<dd><p>Allocate array_view->dictionary. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowArrayViewSetLengthP14ArrowArrayView7int64_t">
+<span id="_CPPv323ArrowArrayViewSetLengthP14ArrowArrayView7int64_t"></span><span id="_CPPv223ArrowArrayViewSetLengthP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewSetLength__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1gae7f1bf5561a443f88801eae25c8c03fe"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArrayViewSetLength</span></spa [...]
+<dd><p>Set data-independent buffer sizes from length. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowArrayViewSetArrayP14ArrowArrayViewP10ArrowArrayP10ArrowError">
+<span id="_CPPv322ArrowArrayViewSetArrayP14ArrowArrayViewP10ArrowArrayP10ArrowError"></span><span id="_CPPv222ArrowArrayViewSetArrayP14ArrowArrayViewP10ArrowArrayP10ArrowError"></span><span id="ArrowArrayViewSetArray__ArrowArrayViewP.ArrowArrayP.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array-view_1gada04cd33265cf33ded2701fb1e365648"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorC [...]
+<dd><p>Set buffer sizes and data pointers from an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowArrayViewValidateP14ArrowArrayView20ArrowValidationLevelP10ArrowError">
+<span id="_CPPv322ArrowArrayViewValidateP14ArrowArrayView20ArrowValidationLevelP10ArrowError"></span><span id="_CPPv222ArrowArrayViewValidateP14ArrowArrayView20ArrowValidationLevelP10ArrowError"></span><span id="ArrowArrayViewValidate__ArrowArrayViewP.ArrowValidationLevel.ArrowErrorP"></span><span class="target" id="group__nanoarrow-array-view_1gaad1f410d559f83791c471313846970bd"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><s [...]
+<dd><p>Performs checks on the content of an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+<p>If using <a class="reference internal" href="#group__nanoarrow-array-view_1gada04cd33265cf33ded2701fb1e365648"><span class="std std-ref">ArrowArrayViewSetArray()</span></a> to back array_view with an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>, the buffer sizes and some content (fist and last offset) have already been validated at the “default” level. If setting the buffer pointers and sizes otherwise, you may wish to perfor [...]
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowArrayViewResetP14ArrowArrayView">
+<span id="_CPPv319ArrowArrayViewResetP14ArrowArrayView"></span><span id="_CPPv219ArrowArrayViewResetP14ArrowArrayView"></span><span id="ArrowArrayViewReset__ArrowArrayViewP"></span><span class="target" id="group__nanoarrow-array-view_1ga983106893cf481272d96fb91dc6d724c"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArrayViewReset</span></span></span><span class="sig-paren">(</span [...]
+<dd><p>Reset the contents of an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> and frees resources. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowArrayViewIsNullP14ArrowArrayView7int64_t">
+<span id="_CPPv320ArrowArrayViewIsNullP14ArrowArrayView7int64_t"></span><span id="_CPPv220ArrowArrayViewIsNullP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewIsNull__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga01e5b0b30fa58f2ee8c4a7507a74f020"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="n"><span class="pr [...]
+<dd><p>Check for a null element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv425ArrowArrayViewUnionTypeIdP14ArrowArrayView7int64_t">
+<span id="_CPPv325ArrowArrayViewUnionTypeIdP14ArrowArrayView7int64_t"></span><span id="_CPPv225ArrowArrayViewUnionTypeIdP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewUnionTypeId__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1gadceccfb2edf264393b88a2e1985e264e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="n"> [...]
+<dd><p>Get the type id of a union array element. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv429ArrowArrayViewUnionChildIndexP14ArrowArrayView7int64_t">
+<span id="_CPPv329ArrowArrayViewUnionChildIndexP14ArrowArrayView7int64_t"></span><span id="_CPPv229ArrowArrayViewUnionChildIndexP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewUnionChildIndex__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1gae4c2175417c784f950113b5d2874033b"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><spa [...]
+<dd><p>Get the child index of a union array element. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv430ArrowArrayViewUnionChildOffsetP14ArrowArrayView7int64_t">
+<span id="_CPPv330ArrowArrayViewUnionChildOffsetP14ArrowArrayView7int64_t"></span><span id="_CPPv230ArrowArrayViewUnionChildOffsetP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewUnionChildOffset__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1gad69ea697c65b3a3c4f31f823cf3e84dd"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span>< [...]
+<dd><p>Get the index to use into the relevant union child array. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowArrayViewGetIntUnsafeP14ArrowArrayView7int64_t">
+<span id="_CPPv326ArrowArrayViewGetIntUnsafeP14ArrowArrayView7int64_t"></span><span id="_CPPv226ArrowArrayViewGetIntUnsafeP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewGetIntUnsafe__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga116de101807afd81b0b5949f0141c785"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class=" [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as an integer. </p>
+<p>This function does not check for null values, that values are actually integers, or that values are within a valid range for an int64. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowArrayViewGetUIntUnsafeP14ArrowArrayView7int64_t">
+<span id="_CPPv327ArrowArrayViewGetUIntUnsafeP14ArrowArrayView7int64_t"></span><span id="_CPPv227ArrowArrayViewGetUIntUnsafeP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewGetUIntUnsafe__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga555c0b465f9c77eb26aa363102b11f19"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span clas [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as an unsigned integer. </p>
+<p>This function does not check for null values, that values are actually integers, or that values are within a valid range for a uint64. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv429ArrowArrayViewGetDoubleUnsafeP14ArrowArrayView7int64_t">
+<span id="_CPPv329ArrowArrayViewGetDoubleUnsafeP14ArrowArrayView7int64_t"></span><span id="_CPPv229ArrowArrayViewGetDoubleUnsafeP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewGetDoubleUnsafe__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga4646cca89ab7fa8165989bc8bb76ad58"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><spa [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as a double. </p>
+<p>This function does not check for null values, or that values are within a valid range for a double. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv429ArrowArrayViewGetStringUnsafeP14ArrowArrayView7int64_t">
+<span id="_CPPv329ArrowArrayViewGetStringUnsafeP14ArrowArrayView7int64_t"></span><span id="_CPPv229ArrowArrayViewGetStringUnsafeP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewGetStringUnsafe__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga4cf36aeb79f398c708f58c091cf3d1ef"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><spa [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as an <a class="reference internal" href="#struct_arrow_string_view"><span class="std std-ref">ArrowStringView</span></a>. </p>
+<p>This function does not check for null values. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv428ArrowArrayViewGetBytesUnsafeP14ArrowArrayView7int64_t">
+<span id="_CPPv328ArrowArrayViewGetBytesUnsafeP14ArrowArrayView7int64_t"></span><span id="_CPPv228ArrowArrayViewGetBytesUnsafeP14ArrowArrayView7int64_t"></span><span id="ArrowArrayViewGetBytesUnsafe__ArrowArrayViewP.int64_t"></span><span class="target" id="group__nanoarrow-array-view_1ga6cb0bd30d8a95ff5dacf0232d401e512"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span c [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as an <a class="reference internal" href="#struct_arrow_buffer_view"><span class="std std-ref">ArrowBufferView</span></a>. </p>
+<p>This function does not check for null values. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv430ArrowArrayViewGetDecimalUnsafeP14ArrowArrayView7int64_tP12ArrowDecimal">
+<span id="_CPPv330ArrowArrayViewGetDecimalUnsafeP14ArrowArrayView7int64_tP12ArrowDecimal"></span><span id="_CPPv230ArrowArrayViewGetDecimalUnsafeP14ArrowArrayView7int64_tP12ArrowDecimal"></span><span id="ArrowArrayViewGetDecimalUnsafe__ArrowArrayViewP.int64_t.ArrowDecimalP"></span><span class="target" id="group__nanoarrow-array-view_1gabb75d3ea198c73f4fe7f494f884476c4"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">i [...]
+<dd><p>Get an element in an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> as an <a class="reference internal" href="#struct_arrow_decimal"><span class="std std-ref">ArrowDecimal</span></a>. </p>
+<p>This function does not check for null values. The out parameter must be initialized with ArrowDecimalInit() with the proper parameters for this type before calling this for the first time. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv414ArrowArrayView">
+<span id="_CPPv314ArrowArrayView"></span><span id="_CPPv214ArrowArrayView"></span><span id="ArrowArrayView"></span><span class="target" id="struct_arrow_array_view"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArrayView</span></span></span><a class="headerlink" href="#_CPPv414ArrowArrayView" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>A non-owning view of an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<p>This data structure provides access to the values contained within an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> with fields provided in a more readily-extractible form. You can re-use an <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> for multiple ArrowArrays with the same storage type, use it to represent a hypothetical <a class="reference internal" href="# [...]
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView5arrayE">
+<span id="_CPPv3N14ArrowArrayView5arrayE"></span><span id="_CPPv2N14ArrowArrayView5arrayE"></span><span id="ArrowArrayView::array__ArrowArrayP"></span><span class="target" id="struct_arrow_array_view_1a3035bf0a4b816cf1ea002575fe1f7182"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv410ArrowArray" title="ArrowArray"><span class="n"><span class="pre">ArrowArray</span></span></a><span class="w"> </span><span cla [...]
+<dd><p>The underlying <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> or NULL if it has not been set or if the buffers in this <a class="reference internal" href="#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a> are not backed by an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView6offsetE">
+<span id="_CPPv3N14ArrowArrayView6offsetE"></span><span id="_CPPv2N14ArrowArrayView6offsetE"></span><span id="ArrowArrayView::offset__int64_t"></span><span class="target" id="struct_arrow_array_view_1ab45c8f3ebbcb199d374bcc9b4e42cf7b"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">offset</span></span></span><a class="headerlink" href="#_CPPv4N14ArrowArrayView6offsetE" title="Permalink [...]
+<dd><p>The number of elements from the physical start of the buffers. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView6lengthE">
+<span id="_CPPv3N14ArrowArrayView6lengthE"></span><span id="_CPPv2N14ArrowArrayView6lengthE"></span><span id="ArrowArrayView::length__int64_t"></span><span class="target" id="struct_arrow_array_view_1a805ba1ff0745735b4eb8b63f34a515c0"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">length</span></span></span><a class="headerlink" href="#_CPPv4N14ArrowArrayView6lengthE" title="Permalink [...]
+<dd><p>The number of elements in this view. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView10null_countE">
+<span id="_CPPv3N14ArrowArrayView10null_countE"></span><span id="_CPPv2N14ArrowArrayView10null_countE"></span><span id="ArrowArrayView::null_count__int64_t"></span><span class="target" id="struct_arrow_array_view_1afc995e6f9d9e4d7141c6e3ec145f7e46"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">null_count</span></span></span><a class="headerlink" href="#_CPPv4N14ArrowArrayView10null_c [...]
+<dd><p>A cached null count or -1 to indicate that this value is unknown. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView12storage_typeE">
+<span id="_CPPv3N14ArrowArrayView12storage_typeE"></span><span id="_CPPv2N14ArrowArrayView12storage_typeE"></span><span id="ArrowArrayView::storage_type__ArrowType"></span><span class="target" id="struct_arrow_array_view_1aed4b4c470602e293fa1616c9c986b876"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv49ArrowType" title="ArrowType"><span class="n"><span class="pre">ArrowType</span></span></a><span class="w"> < [...]
+<dd><p>The type used to store values in this array. </p>
+<p>This type represents only the minimum required information to extract values from the array buffers (e.g., for a Date32 array, this value will be NANOARROW_TYPE_INT32). For dictionary-encoded arrays, this will be the index type. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView6layoutE">
+<span id="_CPPv3N14ArrowArrayView6layoutE"></span><span id="_CPPv2N14ArrowArrayView6layoutE"></span><span id="ArrowArrayView::layout__ArrowLayout"></span><span class="target" id="struct_arrow_array_view_1a073cd0c361fc67550322e299d1560290"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowLayout" title="ArrowLayout"><span class="n"><span class="pre">ArrowLayout</span></span></a><span class="w"> </span><sp [...]
+<dd><p>The buffer types, strides, and sizes of this Array’s buffers. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView12buffer_viewsE">
+<span id="_CPPv3N14ArrowArrayView12buffer_viewsE"></span><span id="_CPPv2N14ArrowArrayView12buffer_viewsE"></span><span id="ArrowArrayView::buffer_views__ArrowBufferViewA"></span><span class="target" id="struct_arrow_array_view_1a35e95d9913866d0c2255f5dbdec8d5bf"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv415ArrowBufferView" title="ArrowBufferView"><span class="n"><span class="pre">ArrowBufferView</span>< [...]
+<dd><p>This Array’s buffers as <a class="reference internal" href="#struct_arrow_buffer_view"><span class="std std-ref">ArrowBufferView</span></a> objects. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView10n_childrenE">
+<span id="_CPPv3N14ArrowArrayView10n_childrenE"></span><span id="_CPPv2N14ArrowArrayView10n_childrenE"></span><span id="ArrowArrayView::n_children__int64_t"></span><span class="target" id="struct_arrow_array_view_1ab095b2788ef615d619bd6f8ff696c5d8"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">n_children</span></span></span><a class="headerlink" href="#_CPPv4N14ArrowArrayView10n_chil [...]
+<dd><p>The number of children of this view. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView8childrenE">
+<span id="_CPPv3N14ArrowArrayView8childrenE"></span><span id="_CPPv2N14ArrowArrayView8childrenE"></span><span id="ArrowArrayView::children__ArrowArrayViewPP"></span><span class="target" id="struct_arrow_array_view_1ace687eb6d009aa26a412beb55513cb55"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowArrayView" title="ArrowArrayView"><span class="n"><span class="pre">ArrowArrayView</span></span></a><span c [...]
+<dd><p>Pointers to views of this array’s children. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView10dictionaryE">
+<span id="_CPPv3N14ArrowArrayView10dictionaryE"></span><span id="_CPPv2N14ArrowArrayView10dictionaryE"></span><span id="ArrowArrayView::dictionary__ArrowArrayViewP"></span><span class="target" id="struct_arrow_array_view_1abc80a5647138b8125debe8f20e73e653"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowArrayView" title="ArrowArrayView"><span class="n"><span class="pre">ArrowArrayView</span></span></a> [...]
+<dd><p>Pointer to a view of this array’s dictionary. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N14ArrowArrayView17union_type_id_mapE">
+<span id="_CPPv3N14ArrowArrayView17union_type_id_mapE"></span><span id="_CPPv2N14ArrowArrayView17union_type_id_mapE"></span><span id="ArrowArrayView::union_type_id_map__int8_tP"></span><span class="target" id="struct_arrow_array_view_1a67e002d726250ad0d9ed0cd84d8cb263"></span><span class="n"><span class="pre">int8_t</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">union_type_id_map</spa [...]
+<dd><p>Union type id to child index mapping. </p>
+<p>If storage_type is a union type, a 256-byte <a class="reference internal" href="#group__nanoarrow-malloc_1gab05bc897baadee2d140b5bea9a846f7b"><span class="std std-ref">ArrowMalloc()</span></a>ed buffer such that child_index == union_type_id_map[type_id] and type_id == union_type_id_map[128 + child_index]. This value may be NULL in the case where child_id == type_id. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="owning-growable-buffers">
+<h2>Owning, growable buffers<a class="headerlink" href="#owning-growable-buffers" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-buffer"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-buffer</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBufferInitP11ArrowBuffer">
+<span id="_CPPv315ArrowBufferInitP11ArrowBuffer"></span><span id="_CPPv215ArrowBufferInitP11ArrowBuffer"></span><span id="ArrowBufferInit__ArrowBufferP"></span><span class="target" id="group__nanoarrow-buffer_1gac85f9e1b00d78ebc2ac388f4fbc3c160"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>. </p>
+<p>Initialize a buffer with a NULL, zero-size buffer using the default buffer allocator. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferSetAllocatorP11ArrowBuffer20ArrowBufferAllocator">
+<span id="_CPPv323ArrowBufferSetAllocatorP11ArrowBuffer20ArrowBufferAllocator"></span><span id="_CPPv223ArrowBufferSetAllocatorP11ArrowBuffer20ArrowBufferAllocator"></span><span id="ArrowBufferSetAllocator__ArrowBufferP.ArrowBufferAllocator"></span><span class="target" id="group__nanoarrow-buffer_1gaad4ce79883f9eecc8350f57c53ca3b6c"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> < [...]
+<dd><p>Set a newly-initialized buffer’s allocator. </p>
+<p>Returns EINVAL if the buffer has already been allocated. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowBufferResetP11ArrowBuffer">
+<span id="_CPPv316ArrowBufferResetP11ArrowBuffer"></span><span id="_CPPv216ArrowBufferResetP11ArrowBuffer"></span><span id="ArrowBufferReset__ArrowBufferP"></span><span class="target" id="group__nanoarrow-buffer_1ga343c15a9d511553878c0c2f54c355d6e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><sp [...]
+<dd><p>Reset an <a class="reference internal" href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>. </p>
+<p>Releases the buffer using the allocator’s free method if the buffer’s data member is non-null, sets the data member to NULL, and sets the buffer’s size and capacity to 0. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBufferMoveP11ArrowBufferP11ArrowBuffer">
+<span id="_CPPv315ArrowBufferMoveP11ArrowBufferP11ArrowBuffer"></span><span id="_CPPv215ArrowBufferMoveP11ArrowBufferP11ArrowBuffer"></span><span id="ArrowBufferMove__ArrowBufferP.ArrowBufferP"></span><span class="target" id="group__nanoarrow-buffer_1gab310f20fc31ebcf68fb09f286f5c5565"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</s [...]
+<dd><p>Move an <a class="reference internal" href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>. </p>
+<p>Transfers the buffer data and lifecycle management to another address and resets buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowBufferResizeP11ArrowBuffer7int64_tc">
+<span id="_CPPv317ArrowBufferResizeP11ArrowBuffer7int64_tc"></span><span id="_CPPv217ArrowBufferResizeP11ArrowBuffer7int64_tc"></span><span id="ArrowBufferResize__ArrowBufferP.int64_t.c"></span><span class="target" id="group__nanoarrow-buffer_1ga7334c70b8fd2db62de0645cce9bb6087"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arro [...]
+<dd><p>Grow or shrink a buffer to a given capacity. </p>
+<p>When shrinking the capacity of the buffer, the buffer is only reallocated if shrink_to_fit is non-zero. Calling ArrowBufferResize() does not adjust the buffer’s size member except to ensure that the invariant capacity >= size remains true. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowBufferReserveP11ArrowBuffer7int64_t">
+<span id="_CPPv318ArrowBufferReserveP11ArrowBuffer7int64_t"></span><span id="_CPPv218ArrowBufferReserveP11ArrowBuffer7int64_t"></span><span id="ArrowBufferReserve__ArrowBufferP.int64_t"></span><span class="target" id="group__nanoarrow-buffer_1ga355bfda26c6bd1db1765076a042ba345"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arrow [...]
+<dd><p>Ensure a buffer has at least a given additional capacity. </p>
+<p>Ensures that the buffer has space to append at least additional_size_bytes, overallocating when required. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t">
+<span id="_CPPv323ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t"></span><span id="_CPPv223ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t"></span><span id="ArrowBufferAppendUnsafe__ArrowBufferP.voidCP.int64_t"></span><span class="target" id="group__nanoarrow-buffer_1ga6afb02edfa7936ecae95936672c768bb"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span [...]
+<dd><p>Write data to buffer and increment the buffer size. </p>
+<p>This function does not check that buffer has the required capacity </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowBufferAppendP11ArrowBufferPKv7int64_t">
+<span id="_CPPv317ArrowBufferAppendP11ArrowBufferPKv7int64_t"></span><span id="_CPPv217ArrowBufferAppendP11ArrowBufferPKv7int64_t"></span><span id="ArrowBufferAppend__ArrowBufferP.voidCP.int64_t"></span><span class="target" id="group__nanoarrow-buffer_1gac8c2d733e4c7313aebc4d248f39f6cbb"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CP [...]
+<dd><p>Write data to buffer and increment the buffer size. </p>
+<p>This function writes and ensures that the buffer has the required capacity, possibly by reallocating the buffer. Like ArrowBufferReserve, this will overallocate when reallocation is required. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowBufferAppendFillP11ArrowBuffer7uint8_t7int64_t">
+<span id="_CPPv321ArrowBufferAppendFillP11ArrowBuffer7uint8_t7int64_t"></span><span id="_CPPv221ArrowBufferAppendFillP11ArrowBuffer7uint8_t7int64_t"></span><span id="ArrowBufferAppendFill__ArrowBufferP.uint8_t.int64_t"></span><span class="target" id="group__nanoarrow-buffer_1gac4bbb86e0b2d23b298394f6e646243e7"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="referen [...]
+<dd><p>Write fill to buffer and increment the buffer size. </p>
+<p>This function writes the specified number of fill bytes and ensures that the buffer has the required capacity, </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowBufferAppendInt8P11ArrowBuffer6int8_t">
+<span id="_CPPv321ArrowBufferAppendInt8P11ArrowBuffer6int8_t"></span><span id="_CPPv221ArrowBufferAppendInt8P11ArrowBuffer6int8_t"></span><span id="ArrowBufferAppendInt8__ArrowBufferP.int8_t"></span><span class="target" id="group__nanoarrow-buffer_1gaeea176364336f15792f3806b6a83a556"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv41 [...]
+<dd><p>Write an 8-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferAppendUInt8P11ArrowBuffer7uint8_t">
+<span id="_CPPv322ArrowBufferAppendUInt8P11ArrowBuffer7uint8_t"></span><span id="_CPPv222ArrowBufferAppendUInt8P11ArrowBuffer7uint8_t"></span><span id="ArrowBufferAppendUInt8__ArrowBufferP.uint8_t"></span><span class="target" id="group__nanoarrow-buffer_1gabf2e92c5b3824fda3f717e57b7e0c45e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_ [...]
+<dd><p>Write an unsigned 8-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferAppendInt16P11ArrowBuffer7int16_t">
+<span id="_CPPv322ArrowBufferAppendInt16P11ArrowBuffer7int16_t"></span><span id="_CPPv222ArrowBufferAppendInt16P11ArrowBuffer7int16_t"></span><span id="ArrowBufferAppendInt16__ArrowBufferP.int16_t"></span><span class="target" id="group__nanoarrow-buffer_1gab09ee38169d62e8ef5314dd9e7fde233"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_ [...]
+<dd><p>Write a 16-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferAppendUInt16P11ArrowBuffer8uint16_t">
+<span id="_CPPv323ArrowBufferAppendUInt16P11ArrowBuffer8uint16_t"></span><span id="_CPPv223ArrowBufferAppendUInt16P11ArrowBuffer8uint16_t"></span><span id="ArrowBufferAppendUInt16__ArrowBufferP.uint16_t"></span><span class="target" id="group__nanoarrow-buffer_1ga86dc0ae3a1d57382dbe4da4b5118dd6b"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" hr [...]
+<dd><p>Write an unsigned 16-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferAppendInt32P11ArrowBuffer7int32_t">
+<span id="_CPPv322ArrowBufferAppendInt32P11ArrowBuffer7int32_t"></span><span id="_CPPv222ArrowBufferAppendInt32P11ArrowBuffer7int32_t"></span><span id="ArrowBufferAppendInt32__ArrowBufferP.int32_t"></span><span class="target" id="group__nanoarrow-buffer_1ga5c36ac40ea35b61b1f845fe4a7ea5247"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_ [...]
+<dd><p>Write a 32-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferAppendUInt32P11ArrowBuffer8uint32_t">
+<span id="_CPPv323ArrowBufferAppendUInt32P11ArrowBuffer8uint32_t"></span><span id="_CPPv223ArrowBufferAppendUInt32P11ArrowBuffer8uint32_t"></span><span id="ArrowBufferAppendUInt32__ArrowBufferP.uint32_t"></span><span class="target" id="group__nanoarrow-buffer_1ga82b0e69bc74da1362f9bde4c00856143"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" hr [...]
+<dd><p>Write an unsigned 32-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferAppendInt64P11ArrowBuffer7int64_t">
+<span id="_CPPv322ArrowBufferAppendInt64P11ArrowBuffer7int64_t"></span><span id="_CPPv222ArrowBufferAppendInt64P11ArrowBuffer7int64_t"></span><span id="ArrowBufferAppendInt64__ArrowBufferP.int64_t"></span><span class="target" id="group__nanoarrow-buffer_1ga7917aee52cf3225e0ec8982dcfd9a570"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_ [...]
+<dd><p>Write a 64-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferAppendUInt64P11ArrowBuffer8uint64_t">
+<span id="_CPPv323ArrowBufferAppendUInt64P11ArrowBuffer8uint64_t"></span><span id="_CPPv223ArrowBufferAppendUInt64P11ArrowBuffer8uint64_t"></span><span id="ArrowBufferAppendUInt64__ArrowBufferP.uint64_t"></span><span class="target" id="group__nanoarrow-buffer_1ga625f65a799abf1efa39002b6dcacb709"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" hr [...]
+<dd><p>Write an unsigned 64-bit integer to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBufferAppendDoubleP11ArrowBufferd">
+<span id="_CPPv323ArrowBufferAppendDoubleP11ArrowBufferd"></span><span id="_CPPv223ArrowBufferAppendDoubleP11ArrowBufferd"></span><span id="ArrowBufferAppendDouble__ArrowBufferP.double"></span><span class="target" id="group__nanoarrow-buffer_1ga92cdc5b9edcfc816fdd12f38be36eb12"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arrow [...]
+<dd><p>Write a double to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferAppendFloatP11ArrowBufferf">
+<span id="_CPPv322ArrowBufferAppendFloatP11ArrowBufferf"></span><span id="_CPPv222ArrowBufferAppendFloatP11ArrowBufferf"></span><span id="ArrowBufferAppendFloat__ArrowBufferP.float"></span><span class="target" id="group__nanoarrow-buffer_1gafe5febfaba36b789579194612819af0f"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414ArrowErro [...]
+<dd><p>Write a float to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowBufferAppendStringViewP11ArrowBuffer15ArrowStringView">
+<span id="_CPPv327ArrowBufferAppendStringViewP11ArrowBuffer15ArrowStringView"></span><span id="_CPPv227ArrowBufferAppendStringViewP11ArrowBuffer15ArrowStringView"></span><span id="ArrowBufferAppendStringView__ArrowBufferP.ArrowStringView"></span><span class="target" id="group__nanoarrow-buffer_1ga8dc7c690ccc330cded565c6b69d84062"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </sp [...]
+<dd><p>Write an <a class="reference internal" href="#struct_arrow_string_view"><span class="std std-ref">ArrowStringView</span></a> to a buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowBufferAppendBufferViewP11ArrowBuffer15ArrowBufferView">
+<span id="_CPPv327ArrowBufferAppendBufferViewP11ArrowBuffer15ArrowBufferView"></span><span id="_CPPv227ArrowBufferAppendBufferViewP11ArrowBuffer15ArrowBufferView"></span><span id="ArrowBufferAppendBufferView__ArrowBufferP.ArrowBufferView"></span><span class="target" id="group__nanoarrow-buffer_1gac2cf5770ad82a1fcf9f78cd43919238a"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </sp [...]
+<dd><p>Write an <a class="reference internal" href="#struct_arrow_buffer_view"><span class="std std-ref">ArrowBufferView</span></a> to a buffer. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowBufferAllocator">
+<span id="_CPPv320ArrowBufferAllocator"></span><span id="_CPPv220ArrowBufferAllocator"></span><span id="ArrowBufferAllocator"></span><span class="target" id="struct_arrow_buffer_allocator"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowBufferAllocator</span></span></span><a class="headerlink" href="#_CPPv420ArrowBufferAllocator" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>Array buffer allocation and deallocation. </p>
+<p>Container for allocate, reallocate, and free methods that can be used to customize allocation and deallocation of buffers when constructing an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowBufferAllocator10reallocateE">
+<span id="_CPPv3N20ArrowBufferAllocator10reallocateE"></span><span id="_CPPv2N20ArrowBufferAllocator10reallocateE"></span><span class="target" id="struct_arrow_buffer_allocator_1ae4f5aae301b26304d7c9400bd65a2953"></span><span class="n"><span class="pre">uint8_t</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n [...]
+<dd><p>Reallocate a buffer or return NULL if it cannot be reallocated. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowBufferAllocator4freeE">
+<span id="_CPPv3N20ArrowBufferAllocator4freeE"></span><span id="_CPPv2N20ArrowBufferAllocator4freeE"></span><span class="target" id="struct_arrow_buffer_allocator_1ac59d10d7f575721f94e5b76974a1af79"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">free</span></span></span><span class="p"><spa [...]
+<dd><p>Deallocate a buffer allocated by this allocator. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N20ArrowBufferAllocator12private_dataE">
+<span id="_CPPv3N20ArrowBufferAllocator12private_dataE"></span><span id="_CPPv2N20ArrowBufferAllocator12private_dataE"></span><span id="ArrowBufferAllocator::private_data__voidP"></span><span class="target" id="struct_arrow_buffer_allocator_1a49f0b026a66c9481b5f564048a1e736a"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">private_data</sp [...]
+<dd><p>Opaque data specific to the allocator. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowBuffer">
+<span id="_CPPv311ArrowBuffer"></span><span id="_CPPv211ArrowBuffer"></span><span id="ArrowBuffer"></span><span class="target" id="struct_arrow_buffer"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowBuffer</span></span></span><a class="headerlink" href="#_CPPv411ArrowBuffer" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>An owning mutable view of a buffer. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBuffer4dataE">
+<span id="_CPPv3N11ArrowBuffer4dataE"></span><span id="_CPPv2N11ArrowBuffer4dataE"></span><span id="ArrowBuffer::data__uint8_tP"></span><span class="target" id="struct_arrow_buffer_1aa5ff388bfabb0675bc5920b7ae05c1ee"></span><span class="n"><span class="pre">uint8_t</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">data</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowBuffer [...]
+<dd><p>A pointer to the start of the buffer. </p>
+<p>If capacity_bytes is 0, this value may be NULL. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBuffer10size_bytesE">
+<span id="_CPPv3N11ArrowBuffer10size_bytesE"></span><span id="_CPPv2N11ArrowBuffer10size_bytesE"></span><span id="ArrowBuffer::size_bytes__int64_t"></span><span class="target" id="struct_arrow_buffer_1a52cd20640e2b397c8a0612aec0eedaf5"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">size_bytes</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowBuffer10size_bytesE" title="Pe [...]
+<dd><p>The size of the buffer in bytes. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBuffer14capacity_bytesE">
+<span id="_CPPv3N11ArrowBuffer14capacity_bytesE"></span><span id="_CPPv2N11ArrowBuffer14capacity_bytesE"></span><span id="ArrowBuffer::capacity_bytes__int64_t"></span><span class="target" id="struct_arrow_buffer_1a237735ef9399f5e26d0d559db792a085"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">capacity_bytes</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowBuffer14capaci [...]
+<dd><p>The capacity of the buffer in bytes. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBuffer9allocatorE">
+<span id="_CPPv3N11ArrowBuffer9allocatorE"></span><span id="_CPPv2N11ArrowBuffer9allocatorE"></span><span id="ArrowBuffer::allocator__ArrowBufferAllocator"></span><span class="target" id="struct_arrow_buffer_1ab8d8407330b2c9ab33c85b66d1219928"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv420ArrowBufferAllocator" title="ArrowBufferAllocator"><span class="n"><span class="pre">ArrowBufferAllocator</span></span [...]
+<dd><p>The allocator that will be used to reallocate and/or free the buffer. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="bitmap-utilities">
+<h2>Bitmap utilities<a class="headerlink" href="#bitmap-utilities" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-bitmap"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-bitmap</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowBitGetPK7uint8_t7int64_t">
+<span id="_CPPv311ArrowBitGetPK7uint8_t7int64_t"></span><span id="_CPPv211ArrowBitGetPK7uint8_t7int64_t"></span><span id="ArrowBitGet__uint8_tCP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga66bb6ec563f8c90dd55856cbc1522757"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="n"><span class="pre">int8_t</span></span><span class="w"> </span><spa [...]
+<dd><p>Extract a boolean value from a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowBitSetP7uint8_t7int64_t">
+<span id="_CPPv311ArrowBitSetP7uint8_t7int64_t"></span><span id="_CPPv211ArrowBitSetP7uint8_t7int64_t"></span><span id="ArrowBitSet__uint8_tP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga2a9cc30717e11b59813a124975569a6a"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span cl [...]
+<dd><p>Set a boolean value to a bitmap to true. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv413ArrowBitClearP7uint8_t7int64_t">
+<span id="_CPPv313ArrowBitClearP7uint8_t7int64_t"></span><span id="_CPPv213ArrowBitClearP7uint8_t7int64_t"></span><span id="ArrowBitClear__uint8_tP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1gaef7decc8c405ecea91f6050547453d0a"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><s [...]
+<dd><p>Set a boolean value to a bitmap to false. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv413ArrowBitSetToP7uint8_t7int64_t7uint8_t">
+<span id="_CPPv313ArrowBitSetToP7uint8_t7int64_t7uint8_t"></span><span id="_CPPv213ArrowBitSetToP7uint8_t7int64_t7uint8_t"></span><span id="ArrowBitSetTo__uint8_tP.int64_t.uint8_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga9900b948593432d514a7175d68c620f7"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><s [...]
+<dd><p>Set a boolean value to a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv414ArrowBitsSetToP7uint8_t7int64_t7int64_t7uint8_t">
+<span id="_CPPv314ArrowBitsSetToP7uint8_t7int64_t7int64_t7uint8_t"></span><span id="_CPPv214ArrowBitsSetToP7uint8_t7int64_t7int64_t7uint8_t"></span><span id="ArrowBitsSetTo__uint8_tP.int64_t.int64_t.uint8_t"></span><span class="target" id="group__nanoarrow-bitmap_1gaee1398dd8c816dc7014961206bfd1493"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class [...]
+<dd><p>Set a boolean value to a range in a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowBitCountSetPK7uint8_t7int64_t7int64_t">
+<span id="_CPPv316ArrowBitCountSetPK7uint8_t7int64_t7int64_t"></span><span id="_CPPv216ArrowBitCountSetPK7uint8_t7int64_t7int64_t"></span><span id="ArrowBitCountSet__uint8_tCP.int64_t.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga4313046e811ff93fdc993423c4904b97"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="n"><span class="pre">int64_t</ [...]
+<dd><p>Count true values in a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBitmapInitP11ArrowBitmap">
+<span id="_CPPv315ArrowBitmapInitP11ArrowBitmap"></span><span id="_CPPv215ArrowBitmapInitP11ArrowBitmap"></span><span id="ArrowBitmapInit__ArrowBitmapP"></span><span class="target" id="group__nanoarrow-bitmap_1gacd63cc6dd7127602a72a7ba994aaabed"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_bitmap"><span class="std std-ref">ArrowBitmap</span></a>. </p>
+<p>Initialize the builder’s buffer, empty its cache, and reset the size to zero </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBitmapMoveP11ArrowBitmapP11ArrowBitmap">
+<span id="_CPPv315ArrowBitmapMoveP11ArrowBitmapP11ArrowBitmap"></span><span id="_CPPv215ArrowBitmapMoveP11ArrowBitmapP11ArrowBitmap"></span><span id="ArrowBitmapMove__ArrowBitmapP.ArrowBitmapP"></span><span class="target" id="group__nanoarrow-bitmap_1ga0080b8cb7bf63665f1f0240c32e37437"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</s [...]
+<dd><p>Move an <a class="reference internal" href="#struct_arrow_bitmap"><span class="std std-ref">ArrowBitmap</span></a>. </p>
+<p>Transfers the underlying buffer data and lifecycle management to another address and resets the bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowBitmapReserveP11ArrowBitmap7int64_t">
+<span id="_CPPv318ArrowBitmapReserveP11ArrowBitmap7int64_t"></span><span id="_CPPv218ArrowBitmapReserveP11ArrowBitmap7int64_t"></span><span id="ArrowBitmapReserve__ArrowBitmapP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga8a1080cb4f1cb2dce6110f3ddc198fcb"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arrow [...]
+<dd><p>Ensure a bitmap builder has at least a given additional capacity. </p>
+<p>Ensures that the buffer has space to append at least additional_size_bits, overallocating when required. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowBitmapResizeP11ArrowBitmap7int64_tc">
+<span id="_CPPv317ArrowBitmapResizeP11ArrowBitmap7int64_tc"></span><span id="_CPPv217ArrowBitmapResizeP11ArrowBitmap7int64_tc"></span><span id="ArrowBitmapResize__ArrowBitmapP.int64_t.c"></span><span class="target" id="group__nanoarrow-bitmap_1ga34e4af39131d13cfd213f7f62aaf9fac"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv414Arro [...]
+<dd><p>Grow or shrink a bitmap to a given capacity. </p>
+<p>When shrinking the capacity of the bitmap, the bitmap is only reallocated if shrink_to_fit is non-zero. Calling ArrowBitmapResize() does not adjust the buffer’s size member except when shrinking new_capacity_bits to a value less than the current number of bits in the bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowBitmapAppendP11ArrowBitmap7uint8_t7int64_t">
+<span id="_CPPv317ArrowBitmapAppendP11ArrowBitmap7uint8_t7int64_t"></span><span id="_CPPv217ArrowBitmapAppendP11ArrowBitmap7uint8_t7int64_t"></span><span id="ArrowBitmapAppend__ArrowBitmapP.uint8_t.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1gab9fa70f0992b02af7eb0843d7d917db7"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" [...]
+<dd><p>Reserve space for and append zero or more of the same boolean value to a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowBitmapAppendUnsafeP11ArrowBitmap7uint8_t7int64_t">
+<span id="_CPPv323ArrowBitmapAppendUnsafeP11ArrowBitmap7uint8_t7int64_t"></span><span id="_CPPv223ArrowBitmapAppendUnsafeP11ArrowBitmap7uint8_t7int64_t"></span><span id="ArrowBitmapAppendUnsafe__ArrowBitmapP.uint8_t.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1gacbbb2d68806fca20c4316c922f12978e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class [...]
+<dd><p>Append zero or more of the same boolean value to a bitmap. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowBitmapAppendInt8UnsafeP11ArrowBitmapPK6int8_t7int64_t">
+<span id="_CPPv327ArrowBitmapAppendInt8UnsafeP11ArrowBitmapPK6int8_t7int64_t"></span><span id="_CPPv227ArrowBitmapAppendInt8UnsafeP11ArrowBitmapPK6int8_t7int64_t"></span><span id="ArrowBitmapAppendInt8Unsafe__ArrowBitmapP.int8_tCP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1ga543fa468114816549b3478c27e81c72e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </s [...]
+<dd><p>Append boolean values encoded as int8_t to a bitmap. </p>
+<p>The values must all be 0 or 1. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv428ArrowBitmapAppendInt32UnsafeP11ArrowBitmapPK7int32_t7int64_t">
+<span id="_CPPv328ArrowBitmapAppendInt32UnsafeP11ArrowBitmapPK7int32_t7int64_t"></span><span id="_CPPv228ArrowBitmapAppendInt32UnsafeP11ArrowBitmapPK7int32_t7int64_t"></span><span id="ArrowBitmapAppendInt32Unsafe__ArrowBitmapP.int32_tCP.int64_t"></span><span class="target" id="group__nanoarrow-bitmap_1gae1fe367ccb49ec588e829fc654ea9220"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w [...]
+<dd><p>Append boolean values encoded as int32_t to a bitmap. </p>
+<p>The values must all be 0 or 1. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowBitmapResetP11ArrowBitmap">
+<span id="_CPPv316ArrowBitmapResetP11ArrowBitmap"></span><span id="_CPPv216ArrowBitmapResetP11ArrowBitmap"></span><span id="ArrowBitmapReset__ArrowBitmapP"></span><span class="target" id="group__nanoarrow-bitmap_1ga1c77e0ca97b6d1ddfe79a867a9ef9c9e"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><sp [...]
+<dd><p>Reset a bitmap builder. </p>
+<p>Releases any memory held by buffer, empties the cache, and resets the size to zero </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowBitmap">
+<span id="_CPPv311ArrowBitmap"></span><span id="_CPPv211ArrowBitmap"></span><span id="ArrowBitmap"></span><span class="target" id="struct_arrow_bitmap"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowBitmap</span></span></span><a class="headerlink" href="#_CPPv411ArrowBitmap" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>An owning mutable view of a bitmap. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBitmap6bufferE">
+<span id="_CPPv3N11ArrowBitmap6bufferE"></span><span id="_CPPv2N11ArrowBitmap6bufferE"></span><span id="ArrowBitmap::buffer__ArrowBuffer"></span><span class="target" id="struct_arrow_bitmap_1ab3864046459e5377dad6e05ff0b46e43"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowBuffer" title="ArrowBuffer"><span class="n"><span class="pre">ArrowBuffer</span></span></a><span class="w"> </span><span class="sig [...]
+<dd><p>An <a class="reference internal" href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a> to hold the allocated memory. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowBitmap9size_bitsE">
+<span id="_CPPv3N11ArrowBitmap9size_bitsE"></span><span id="_CPPv2N11ArrowBitmap9size_bitsE"></span><span id="ArrowBitmap::size_bits__int64_t"></span><span class="target" id="struct_arrow_bitmap_1ac5815138ae9ee52c801fa803541b3f45"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">size_bits</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowBitmap9size_bitsE" title="Permalink [...]
+<dd><p>The number of bits that have been appended to the bitmap. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="create-read-and-modify-schema-metadata">
+<h2>Create, read, and modify schema metadata<a class="headerlink" href="#create-read-and-modify-schema-metadata" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-metadata"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-metadata</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowMetadataReaderInitP19ArrowMetadataReaderPKc">
+<span id="_CPPv323ArrowMetadataReaderInitP19ArrowMetadataReaderPKc"></span><span id="_CPPv223ArrowMetadataReaderInitP19ArrowMetadataReaderPKc"></span><span id="ArrowMetadataReaderInit__ArrowMetadataReaderP.cCP"></span><span class="target" id="group__nanoarrow-metadata_1ga89254adeb3594ff8ca0d476ab47c0e8c"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span [...]
+<dd><p>Initialize an <a class="reference internal" href="#struct_arrow_metadata_reader"><span class="std std-ref">ArrowMetadataReader</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowMetadataReaderReadP19ArrowMetadataReaderP15ArrowStringViewP15ArrowStringView">
+<span id="_CPPv323ArrowMetadataReaderReadP19ArrowMetadataReaderP15ArrowStringViewP15ArrowStringView"></span><span id="_CPPv223ArrowMetadataReaderReadP19ArrowMetadataReaderP15ArrowStringViewP15ArrowStringView"></span><span id="ArrowMetadataReaderRead__ArrowMetadataReaderP.ArrowStringViewP.ArrowStringViewP"></span><span class="target" id="group__nanoarrow-metadata_1ga7a6eb4c0792e56bcfb207859422398f5"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode" [...]
+<dd><p>Read the next key/value pair from an <a class="reference internal" href="#struct_arrow_metadata_reader"><span class="std std-ref">ArrowMetadataReader</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowMetadataSizeOfPKc">
+<span id="_CPPv319ArrowMetadataSizeOfPKc"></span><span id="_CPPv219ArrowMetadataSizeOfPKc"></span><span id="ArrowMetadataSizeOf__cCP"></span><span class="target" id="group__nanoarrow-metadata_1gaabd80297b7447691b8e06356bd9255c7"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowMetadataSizeOf</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const [...]
+<dd><p>The number of bytes in in a key/value metadata string. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowMetadataHasKeyPKc15ArrowStringView">
+<span id="_CPPv319ArrowMetadataHasKeyPKc15ArrowStringView"></span><span id="_CPPv219ArrowMetadataHasKeyPKc15ArrowStringView"></span><span id="ArrowMetadataHasKey__cCP.ArrowStringView"></span><span class="target" id="group__nanoarrow-metadata_1ga56fdfaaf8c3d923696a605f25f1f66ae"></span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowMetadataHasKey</span></span></span><span class="sig-paren" [...]
+<dd><p>Check for a key in schema metadata. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowMetadataGetValuePKc15ArrowStringViewP15ArrowStringView">
+<span id="_CPPv321ArrowMetadataGetValuePKc15ArrowStringViewP15ArrowStringView"></span><span id="_CPPv221ArrowMetadataGetValuePKc15ArrowStringViewP15ArrowStringView"></span><span id="ArrowMetadataGetValue__cCP.ArrowStringView.ArrowStringViewP"></span><span class="target" id="group__nanoarrow-metadata_1ga154a131dd727d341a3228c853da70b3e"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span>< [...]
+<dd><p>Extract a value from schema metadata. </p>
+<p>If key does not exist in metadata, value_out is unmodified </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowMetadataBuilderInitP11ArrowBufferPKc">
+<span id="_CPPv324ArrowMetadataBuilderInitP11ArrowBufferPKc"></span><span id="_CPPv224ArrowMetadataBuilderInitP11ArrowBufferPKc"></span><span id="ArrowMetadataBuilderInit__ArrowBufferP.cCP"></span><span class="target" id="group__nanoarrow-metadata_1ga1fd3676ba441f4f9430315a73869e808"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name desc [...]
+<dd><p>Initialize a builder for schema metadata from key/value pairs. </p>
+<p>metadata can be an existing metadata string or NULL to initialize an empty metadata string. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowMetadataBuilderAppendP11ArrowBuffer15ArrowStringView15ArrowStringView">
+<span id="_CPPv326ArrowMetadataBuilderAppendP11ArrowBuffer15ArrowStringView15ArrowStringView"></span><span id="_CPPv226ArrowMetadataBuilderAppendP11ArrowBuffer15ArrowStringView15ArrowStringView"></span><span id="ArrowMetadataBuilderAppend__ArrowBufferP.ArrowStringView.ArrowStringView"></span><span class="target" id="group__nanoarrow-metadata_1ga3a14a413a8570d3f96d15255c3f1fc7a"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><spa [...]
+<dd><p>Append a key/value pair to a buffer containing serialized metadata. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv423ArrowMetadataBuilderSetP11ArrowBuffer15ArrowStringView15ArrowStringView">
+<span id="_CPPv323ArrowMetadataBuilderSetP11ArrowBuffer15ArrowStringView15ArrowStringView"></span><span id="_CPPv223ArrowMetadataBuilderSetP11ArrowBuffer15ArrowStringView15ArrowStringView"></span><span id="ArrowMetadataBuilderSet__ArrowBufferP.ArrowStringView.ArrowStringView"></span><span class="target" id="group__nanoarrow-metadata_1ga4d8fca20ce7049d66a6445df1a2d83e0"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class=" [...]
+<dd><p>Set a key/value pair to a buffer containing serialized metadata. </p>
+<p>Ensures that the only entry for key in the metadata is set to value. This function maintains the existing position of (the first instance of) key if present in the data. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv426ArrowMetadataBuilderRemoveP11ArrowBuffer15ArrowStringView">
+<span id="_CPPv326ArrowMetadataBuilderRemoveP11ArrowBuffer15ArrowStringView"></span><span id="_CPPv226ArrowMetadataBuilderRemoveP11ArrowBuffer15ArrowStringView"></span><span id="ArrowMetadataBuilderRemove__ArrowBufferP.ArrowStringView"></span><span class="target" id="group__nanoarrow-metadata_1ga093520d83b6d21c836e178b900ff96b1"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><spa [...]
+<dd><p>Remove a key from a buffer containing serialized metadata. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowMetadataReader">
+<span id="_CPPv319ArrowMetadataReader"></span><span id="_CPPv219ArrowMetadataReader"></span><span id="ArrowMetadataReader"></span><span class="target" id="struct_arrow_metadata_reader"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowMetadataReader</span></span></span><a class="headerlink" href="#_CPPv419ArrowMetadataReader" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow.h></em></div>
+<p>Reader for key/value pairs in schema metadata. </p>
+<p>The <a class="reference internal" href="#struct_arrow_metadata_reader"><span class="std std-ref">ArrowMetadataReader</span></a> does not own any data and is only valid for the lifetime of the underlying metadata pointer. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N19ArrowMetadataReader8metadataE">
+<span id="_CPPv3N19ArrowMetadataReader8metadataE"></span><span id="_CPPv2N19ArrowMetadataReader8metadataE"></span><span id="ArrowMetadataReader::metadata__cCP"></span><span class="target" id="struct_arrow_metadata_reader_1ae5ab9868587ac1b569db827307cb9284"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name des [...]
+<dd><p>A metadata string from a schema->metadata field. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N19ArrowMetadataReader6offsetE">
+<span id="_CPPv3N19ArrowMetadataReader6offsetE"></span><span id="_CPPv2N19ArrowMetadataReader6offsetE"></span><span id="ArrowMetadataReader::offset__int64_t"></span><span class="target" id="struct_arrow_metadata_reader_1a80cec1f7461778444d67b9a44bb5b5c0"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">offset</span></span></span><a class="headerlink" href="#_CPPv4N19ArrowMetadataReader6 [...]
+<dd><p>The current offset into the metadata string. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N19ArrowMetadataReader14remaining_keysE">
+<span id="_CPPv3N19ArrowMetadataReader14remaining_keysE"></span><span id="_CPPv2N19ArrowMetadataReader14remaining_keysE"></span><span id="ArrowMetadataReader::remaining_keys__int32_t"></span><span class="target" id="struct_arrow_metadata_reader_1a9f5901986ea3343e0648b3abf155bfc3"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">remaining_keys</span></span></span><a class="headerlink" hr [...]
+<dd><p>The number of remaining keys. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="memory-management">
+<h2>Memory management<a class="headerlink" href="#memory-management" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-malloc"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-malloc</span></span></dt>
+<dd><p>Non-buffer members of a struct <a class="reference internal" href="#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a> and struct <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> must be allocated using <a class="reference internal" href="#group__nanoarrow-malloc_1gab05bc897baadee2d140b5bea9a846f7b"><span class="std std-ref">ArrowMalloc()</span></a> or <a class="reference internal" href="#group__nanoarrow-m [...]
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowMalloc7int64_t">
+<span id="_CPPv311ArrowMalloc7int64_t"></span><span id="_CPPv211ArrowMalloc7int64_t"></span><span id="ArrowMalloc__int64_t"></span><span class="target" id="group__nanoarrow-malloc_1gab05bc897baadee2d140b5bea9a846f7b"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">ArrowMalloc</span></span></span><span class="sig-paren">(</span><span class= [...]
+<dd><p>Allocate like malloc() </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412ArrowReallocPv7int64_t">
+<span id="_CPPv312ArrowReallocPv7int64_t"></span><span id="_CPPv212ArrowReallocPv7int64_t"></span><span id="ArrowRealloc__voidP.int64_t"></span><span class="target" id="group__nanoarrow-malloc_1ga3ae6c5f200450ea143c24613f4d115ac"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">ArrowRealloc</span></span></span><span class="sig-paren">(</spa [...]
+<dd><p>Reallocate like realloc() </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv49ArrowFreePv">
+<span id="_CPPv39ArrowFreePv"></span><span id="_CPPv29ArrowFreePv"></span><span id="ArrowFree__voidP"></span><span class="target" id="group__nanoarrow-malloc_1gaa9552e61d8cce6520ef578d0c8c73860"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowFree</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span cl [...]
+<dd><p>Free a pointer allocated using <a class="reference internal" href="#group__nanoarrow-malloc_1gab05bc897baadee2d140b5bea9a846f7b"><span class="std std-ref">ArrowMalloc()</span></a> or <a class="reference internal" href="#group__nanoarrow-malloc_1ga3ae6c5f200450ea143c24613f4d115ac"><span class="std std-ref">ArrowRealloc()</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv427ArrowBufferAllocatorDefaultv">
+<span id="_CPPv327ArrowBufferAllocatorDefaultv"></span><span id="_CPPv227ArrowBufferAllocatorDefaultv"></span><span id="ArrowBufferAllocatorDefault__void"></span><span class="target" id="group__nanoarrow-malloc_1ga16e318a807ccd9c3dda92d5fda9ed67e"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv420ArrowBufferAllocator" title="ArrowBufferAllocator"><span class="n"><span class="pre">ArrowBufferAllocator</span></ [...]
+<dd><p>Return the default allocator. </p>
+<p>The default allocator uses <a class="reference internal" href="#group__nanoarrow-malloc_1gab05bc897baadee2d140b5bea9a846f7b"><span class="std std-ref">ArrowMalloc()</span></a>, <a class="reference internal" href="#group__nanoarrow-malloc_1ga3ae6c5f200450ea143c24613f4d115ac"><span class="std std-ref">ArrowRealloc()</span></a>, and <a class="reference internal" href="#group__nanoarrow-malloc_1gaa9552e61d8cce6520ef578d0c8c73860"><span class="std std-ref">ArrowFree()</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv">
+<span id="_CPPv322ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv"></span><span id="_CPPv222ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv"></span><span class="target" id="group__nanoarrow-malloc_1ga47bb3e6551ae911f2a7a084724617099"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv420ArrowBufferAllocator" title="ArrowBufferAllocator"><span class="n"><span class="pre">A [...]
+<dd><p>Create a custom deallocator. </p>
+<p>Creates a buffer allocator with only a free method that can be used to attach a custom deallocator to an <a class="reference internal" href="#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>. This may be used to avoid copying an existing buffer that was not allocated using the infrastructure provided here (e.g., by an R or Python object). </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</section>
+<section id="error-handling">
+<h2>Error handling<a class="headerlink" href="#error-handling" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-errors"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-errors</span></span></dt>
+<dd><p>Functions generally return an errno-compatible error code; functions that need to communicate more verbose error information accept a pointer to an <a class="reference internal" href="#struct_arrow_error"><span class="std std-ref">ArrowError</span></a>. This can be stack or statically allocated. The content of the message is undefined unless an error code has been returned. If a nanoarrow function is passed a non-null <a class="reference internal" href="#struct_arrow_error"><span [...]
+<p>Except where documented, it is generally not safe to continue after a function has returned a non-zero ArrowErrorCode. The NANOARROW_RETURN_NOT_OK and NANOARROW_ASSERT_OK macros are provided to help propagate errors. C++ clients can use the helpers provided in the nanoarrow.hpp header to facilitate using C++ idioms for memory management and error propgagtion. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-defines">Defines</p>
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.NANOARROW_OK">
+<span class="target" id="group__nanoarrow-errors_1ga007cefbf896afbd6d30d4226d773a7d5"></span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_OK</span></span></span><a class="headerlink" href="#c.NANOARROW_OK" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Return code for success. </p>
+</dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.NANOARROW_RETURN_NOT_OK">
+<span class="target" id="group__nanoarrow-errors_1gadded0e0e389c1711f6ee55885f0960fd"></span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_RETURN_NOT_OK</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">EXPR</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.NANOARROW_RETURN_NOT_OK" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Check the result of an expression and return it if not NANOARROW_OK. </p>
+</dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.NANOARROW_RETURN_NOT_OK_WITH_ERROR">
+<span class="target" id="group__nanoarrow-errors_1ga451f1a4d74fac95ca5e02398b16713bb"></span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_RETURN_NOT_OK_WITH_ERROR</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">EXPR</span></span>, <span class="n"><span class="pre">ERROR_EXPR</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.NANOARROW_RETURN_NOT_OK_WITH_ERROR" title="Permalink to this definition [...]
+<dd><p>Check the result of an expression and return it if not NANOARROW_OK, adding an auto-generated message to an <a class="reference internal" href="#struct_arrow_error"><span class="std std-ref">ArrowError</span></a>. </p>
+<p>This macro is used to ensure that functions that accept an <a class="reference internal" href="#struct_arrow_error"><span class="std std-ref">ArrowError</span></a> as input always set its message when returning an error code (e.g., when calling a nanoarrow function that does <em>not</em> accept <a class="reference internal" href="#struct_arrow_error"><span class="std std-ref">ArrowError</span></a>). </p>
+</dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-typedefs">Typedefs</p>
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv414ArrowErrorCode">
+<span id="_CPPv314ArrowErrorCode"></span><span id="_CPPv214ArrowErrorCode"></span><span id="ArrowErrorCode"></span><span class="target" id="group__nanoarrow-errors_1ga7a5fb5dd2afa900c7b5f1d78b5da92c8"></span><span class="k"><span class="pre">typedef</span></span><span class="w"> </span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowErrorCode</span></span></span><a class="headerlink" href=" [...]
+<dd><p>Represents an errno-compatible error code. </p>
+</dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv414ArrowErrorInitP10ArrowError">
+<span id="_CPPv314ArrowErrorInitP10ArrowError"></span><span id="_CPPv214ArrowErrorInitP10ArrowError"></span><span id="ArrowErrorInit__ArrowErrorP"></span><span class="target" id="group__nanoarrow-errors_1ga83bb6736f6a4b2bc860731e10116154c"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class= [...]
+<dd><p>Ensure an <a class="reference internal" href="#struct_arrow_error"><span class="std std-ref">ArrowError</span></a> is null-terminated by zeroing the first character. </p>
+<p>If error is NULL, this function does nothing. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv413ArrowErrorSetP10ArrowErrorPKcz">
+<span id="_CPPv313ArrowErrorSetP10ArrowErrorPKcz"></span><span id="_CPPv213ArrowErrorSetP10ArrowErrorPKcz"></span><span id="ArrowErrorSet__ArrowErrorP.cCP.z"></span><span class="target" id="group__nanoarrow-errors_1ga505469650d679b2fa680f31bdbc457cd"></span><a class="reference internal" href="#_CPPv414ArrowErrorCode" title="ArrowErrorCode"><span class="n"><span class="pre">ArrowErrorCode</span></span></a><span class="w"> </span><span class="sig-name descname"><span class="n"><span class= [...]
+<dd><p>Set the contents of an error using printf syntax. </p>
+<p>If error is NULL, this function does nothing and returns NANOARROW_OK. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv417ArrowErrorMessageP10ArrowError">
+<span id="_CPPv317ArrowErrorMessageP10ArrowError"></span><span id="_CPPv217ArrowErrorMessageP10ArrowError"></span><span id="ArrowErrorMessage__ArrowErrorP"></span><span class="target" id="group__nanoarrow-errors_1gaefec4255da8f1a584c6fc8ef357d7b13"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname">< [...]
+<dd><p>Get the contents of an error. </p>
+<p>If error is NULL, returns “”, or returns the contents of the error message otherwise. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv410ArrowError">
+<span id="_CPPv310ArrowError"></span><span id="_CPPv210ArrowError"></span><span id="ArrowError"></span><span class="target" id="struct_arrow_error"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowError</span></span></span><a class="headerlink" href="#_CPPv410ArrowError" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow.h></em></div>
+<p>Error type containing a UTF-8 encoded message. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowError7messageE">
+<span id="_CPPv3N10ArrowError7messageE"></span><span id="_CPPv2N10ArrowError7messageE"></span><span id="ArrowError::message__cA"></span><span class="target" id="struct_arrow_error_1a2d28a3dfc0ad6376e30794b3adacd879"></span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">message</span></span></span><span class="p"><span class="pre">[</span></span><span class="m"><span class="pre">1024</span></sp [...]
+<dd><p>A character buffer with space for an error message. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="utility-data-structures">
+<h2>Utility data structures<a class="headerlink" href="#utility-data-structures" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-utils"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-utils</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-enums">Enums</p>
+<dl class="cpp enum">
+<dt class="sig sig-object cpp" id="_CPPv49ArrowType">
+<span id="_CPPv39ArrowType"></span><span id="_CPPv29ArrowType"></span><span class="target" id="group__nanoarrow-utils_1gae040d7d64b46dd1dc796225aa77c2112"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowType</span></span></span><a class="headerlink" href="#_CPPv49ArrowType" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Arrow type enumerator. </p>
+<p>These names are intended to map to the corresponding arrow::Type::type enumerator; however, the numeric values are specifically not equal (i.e., do not rely on numeric comparison). </p>
+<p><em>Values:</em></p>
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType28NANOARROW_TYPE_UNINITIALIZEDE">
+<span id="_CPPv3N9ArrowType28NANOARROW_TYPE_UNINITIALIZEDE"></span><span id="_CPPv2N9ArrowType28NANOARROW_TYPE_UNINITIALIZEDE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ab746c1cb07ff4ccc99d414e38b9263aa"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_UNINITIALIZED</span></span></span><a class="headerlink" href="#_CPPv4 [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType17NANOARROW_TYPE_NAE">
+<span id="_CPPv3N9ArrowType17NANOARROW_TYPE_NAE"></span><span id="_CPPv2N9ArrowType17NANOARROW_TYPE_NAE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a73727f2b52aefe322c7d467946058815"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_NA</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType17NANOARROW_TYPE_NAE" [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType19NANOARROW_TYPE_BOOLE">
+<span id="_CPPv3N9ArrowType19NANOARROW_TYPE_BOOLE"></span><span id="_CPPv2N9ArrowType19NANOARROW_TYPE_BOOLE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a0b3a1ba0ae1d30a753746118d7b62906"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_BOOL</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType19NANOARROW_TYPE [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType20NANOARROW_TYPE_UINT8E">
+<span id="_CPPv3N9ArrowType20NANOARROW_TYPE_UINT8E"></span><span id="_CPPv2N9ArrowType20NANOARROW_TYPE_UINT8E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a10896d55f67c64fc7817825442aa0ade"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_UINT8</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType20NANOARROW_T [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType19NANOARROW_TYPE_INT8E">
+<span id="_CPPv3N9ArrowType19NANOARROW_TYPE_INT8E"></span><span id="_CPPv2N9ArrowType19NANOARROW_TYPE_INT8E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112acef626769a554bb68336c1d8c3c65244"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INT8</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType19NANOARROW_TYPE [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_UINT16E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_UINT16E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_UINT16E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ad6e837af09a0c1a0f7fcf22b3467c592"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_UINT16</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType20NANOARROW_TYPE_INT16E">
+<span id="_CPPv3N9ArrowType20NANOARROW_TYPE_INT16E"></span><span id="_CPPv2N9ArrowType20NANOARROW_TYPE_INT16E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ab2801469dad4d8a64ede3ece8bce3d6b"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INT16</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType20NANOARROW_T [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_UINT32E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_UINT32E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_UINT32E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a5ce61e933df61ab70fd3c913566c86ca"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_UINT32</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType20NANOARROW_TYPE_INT32E">
+<span id="_CPPv3N9ArrowType20NANOARROW_TYPE_INT32E"></span><span id="_CPPv2N9ArrowType20NANOARROW_TYPE_INT32E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a77eeab0486c65aec2f6078a6b790528f"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INT32</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType20NANOARROW_T [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_UINT64E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_UINT64E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_UINT64E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a71e02a3b752e3d7957f9446a39ffb94c"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_UINT64</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType20NANOARROW_TYPE_INT64E">
+<span id="_CPPv3N9ArrowType20NANOARROW_TYPE_INT64E"></span><span id="_CPPv2N9ArrowType20NANOARROW_TYPE_INT64E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a61bdb807f79a95047f8b974ef1d6c935"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INT64</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType20NANOARROW_T [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType25NANOARROW_TYPE_HALF_FLOATE">
+<span id="_CPPv3N9ArrowType25NANOARROW_TYPE_HALF_FLOATE"></span><span id="_CPPv2N9ArrowType25NANOARROW_TYPE_HALF_FLOATE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a7db66450ba8f3888189a9efa8e36938e"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_HALF_FLOAT</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowTy [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType20NANOARROW_TYPE_FLOATE">
+<span id="_CPPv3N9ArrowType20NANOARROW_TYPE_FLOATE"></span><span id="_CPPv2N9ArrowType20NANOARROW_TYPE_FLOATE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a00eda8c13e2e56455f029fd0c725cb41"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_FLOAT</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType20NANOARROW_T [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_DOUBLEE">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_DOUBLEE"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_DOUBLEE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a083479e678847d7003b3256d96144b29"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DOUBLE</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_STRINGE">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_STRINGE"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_STRINGE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a6e120d06775ba24484bf64cd11992a47"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_STRING</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_BINARYE">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_BINARYE"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_BINARYE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a8ee5afb2525038c20e185307926af515"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_BINARY</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType32NANOARROW_TYPE_FIXED_SIZE_BINARYE">
+<span id="_CPPv3N9ArrowType32NANOARROW_TYPE_FIXED_SIZE_BINARYE"></span><span id="_CPPv2N9ArrowType32NANOARROW_TYPE_FIXED_SIZE_BINARYE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a771f24b554e71dcff8b797aa1d3502dc"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_FIXED_SIZE_BINARY</span></span></span><a class="headerlink" h [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_DATE32E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_DATE32E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_DATE32E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a6e30d0018e6506c9a478b86bbcaa23f7"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DATE32</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_DATE64E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_DATE64E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_DATE64E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112abf52d9c05682a4693ca4b22ca9795ce6"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DATE64</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType24NANOARROW_TYPE_TIMESTAMPE">
+<span id="_CPPv3N9ArrowType24NANOARROW_TYPE_TIMESTAMPE"></span><span id="_CPPv2N9ArrowType24NANOARROW_TYPE_TIMESTAMPE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ac0a42c3b1b1d4ed6990eeba778e22b75"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_TIMESTAMP</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType2 [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_TIME32E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_TIME32E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_TIME32E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a0fd9cc2ecb3faed39a0a1f8778888cda"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_TIME32</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_TIME64E">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_TIME64E"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_TIME64E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a76c431a0dddb6a66e9b4c87c31fb0fa4"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_TIME64</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType30NANOARROW_TYPE_INTERVAL_MONTHSE">
+<span id="_CPPv3N9ArrowType30NANOARROW_TYPE_INTERVAL_MONTHSE"></span><span id="_CPPv2N9ArrowType30NANOARROW_TYPE_INTERVAL_MONTHSE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a70a8a5eb78835e393818a7e57ab8bfc9"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INTERVAL_MONTHS</span></span></span><a class="headerlink" href="# [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType32NANOARROW_TYPE_INTERVAL_DAY_TIMEE">
+<span id="_CPPv3N9ArrowType32NANOARROW_TYPE_INTERVAL_DAY_TIMEE"></span><span id="_CPPv2N9ArrowType32NANOARROW_TYPE_INTERVAL_DAY_TIMEE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ad0f85038f8d7df4372e06c00b1778362"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INTERVAL_DAY_TIME</span></span></span><a class="headerlink" h [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL128E">
+<span id="_CPPv3N9ArrowType25NANOARROW_TYPE_DECIMAL128E"></span><span id="_CPPv2N9ArrowType25NANOARROW_TYPE_DECIMAL128E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a33270e33fcbdad2bf2ddda43e3ddc876"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DECIMAL128</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowTy [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL256E">
+<span id="_CPPv3N9ArrowType25NANOARROW_TYPE_DECIMAL256E"></span><span id="_CPPv2N9ArrowType25NANOARROW_TYPE_DECIMAL256E"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a84696f5595041919b9d5647d64412f7c"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DECIMAL256</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowTy [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType19NANOARROW_TYPE_LISTE">
+<span id="_CPPv3N9ArrowType19NANOARROW_TYPE_LISTE"></span><span id="_CPPv2N9ArrowType19NANOARROW_TYPE_LISTE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a48fa1fcf3b2956e237fe722ca993a497"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_LIST</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType19NANOARROW_TYPE [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType21NANOARROW_TYPE_STRUCTE">
+<span id="_CPPv3N9ArrowType21NANOARROW_TYPE_STRUCTE"></span><span id="_CPPv2N9ArrowType21NANOARROW_TYPE_STRUCTE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112aa38ac193f6727c8a2c69e408d84bdbc1"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_STRUCT</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType21NANOARRO [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType27NANOARROW_TYPE_SPARSE_UNIONE">
+<span id="_CPPv3N9ArrowType27NANOARROW_TYPE_SPARSE_UNIONE"></span><span id="_CPPv2N9ArrowType27NANOARROW_TYPE_SPARSE_UNIONE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ab9b8348e189b6d9e191b449cd81ddb08"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_SPARSE_UNION</span></span></span><a class="headerlink" href="#_CPPv4N9A [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType26NANOARROW_TYPE_DENSE_UNIONE">
+<span id="_CPPv3N9ArrowType26NANOARROW_TYPE_DENSE_UNIONE"></span><span id="_CPPv2N9ArrowType26NANOARROW_TYPE_DENSE_UNIONE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112abec1e41c81d90b7094c6d2191fd765fb"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DENSE_UNION</span></span></span><a class="headerlink" href="#_CPPv4N9Arro [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType25NANOARROW_TYPE_DICTIONARYE">
+<span id="_CPPv3N9ArrowType25NANOARROW_TYPE_DICTIONARYE"></span><span id="_CPPv2N9ArrowType25NANOARROW_TYPE_DICTIONARYE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a516dffded82c8bcb046411c752e8ba93"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DICTIONARY</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowTy [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType18NANOARROW_TYPE_MAPE">
+<span id="_CPPv3N9ArrowType18NANOARROW_TYPE_MAPE"></span><span id="_CPPv2N9ArrowType18NANOARROW_TYPE_MAPE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ab3b43d3257c276c7b94045d52a394442"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_MAP</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType18NANOARROW_TYPE_MA [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType24NANOARROW_TYPE_EXTENSIONE">
+<span id="_CPPv3N9ArrowType24NANOARROW_TYPE_EXTENSIONE"></span><span id="_CPPv2N9ArrowType24NANOARROW_TYPE_EXTENSIONE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112af53d6166608e7f8e1b188f3b9c2b4182"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_EXTENSION</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType2 [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType30NANOARROW_TYPE_FIXED_SIZE_LISTE">
+<span id="_CPPv3N9ArrowType30NANOARROW_TYPE_FIXED_SIZE_LISTE"></span><span id="_CPPv2N9ArrowType30NANOARROW_TYPE_FIXED_SIZE_LISTE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a14ddc81fde0ef9c0618c90ad878e66aa"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_FIXED_SIZE_LIST</span></span></span><a class="headerlink" href="# [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType23NANOARROW_TYPE_DURATIONE">
+<span id="_CPPv3N9ArrowType23NANOARROW_TYPE_DURATIONE"></span><span id="_CPPv2N9ArrowType23NANOARROW_TYPE_DURATIONE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112abfad768a3d9ecf4d053a1e9413355bd7"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_DURATION</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowType23NA [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_STRINGE">
+<span id="_CPPv3N9ArrowType27NANOARROW_TYPE_LARGE_STRINGE"></span><span id="_CPPv2N9ArrowType27NANOARROW_TYPE_LARGE_STRINGE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a8903da4c674d879f9ab6349a5d49f003"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_LARGE_STRING</span></span></span><a class="headerlink" href="#_CPPv4N9A [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_BINARYE">
+<span id="_CPPv3N9ArrowType27NANOARROW_TYPE_LARGE_BINARYE"></span><span id="_CPPv2N9ArrowType27NANOARROW_TYPE_LARGE_BINARYE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a76d46577042b72538298c43d2f354295"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_LARGE_BINARY</span></span></span><a class="headerlink" href="#_CPPv4N9A [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType25NANOARROW_TYPE_LARGE_LISTE">
+<span id="_CPPv3N9ArrowType25NANOARROW_TYPE_LARGE_LISTE"></span><span id="_CPPv2N9ArrowType25NANOARROW_TYPE_LARGE_LISTE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112ade0f94848d6a85b4b28b327fed3e0015"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_LARGE_LIST</span></span></span><a class="headerlink" href="#_CPPv4N9ArrowTy [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N9ArrowType38NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANOE">
+<span id="_CPPv3N9ArrowType38NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANOE"></span><span id="_CPPv2N9ArrowType38NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANOE"></span><span class="target" id="group__nanoarrow-utils_1ggae040d7d64b46dd1dc796225aa77c2112a33c39bc0f36725f86120c38c3d456070"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO</span></span></span><a cl [...]
+<dd></dd></dl>
+
+</dd></dl>
+
+<dl class="cpp enum">
+<dt class="sig sig-object cpp" id="_CPPv413ArrowTimeUnit">
+<span id="_CPPv313ArrowTimeUnit"></span><span id="_CPPv213ArrowTimeUnit"></span><span class="target" id="group__nanoarrow-utils_1ga7048580e7cf78a7d6baac47a6b39e1ac"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowTimeUnit</span></span></span><a class="headerlink" href="#_CPPv413ArrowTimeUnit" title="Permalink to this definition">#</a><br /></dt>
+<dd><p>Arrow time unit enumerator. </p>
+<p>These names and values map to the corresponding arrow::TimeUnit::type enumerator. </p>
+<p><em>Values:</em></p>
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N13ArrowTimeUnit26NANOARROW_TIME_UNIT_SECONDE">
+<span id="_CPPv3N13ArrowTimeUnit26NANOARROW_TIME_UNIT_SECONDE"></span><span id="_CPPv2N13ArrowTimeUnit26NANOARROW_TIME_UNIT_SECONDE"></span><span class="target" id="group__nanoarrow-utils_1gga7048580e7cf78a7d6baac47a6b39e1aca5bc21e6c8d406c9c36da2ba85663cd73"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TIME_UNIT_SECOND</span></span></span><a class="headerlink" href="#_C [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MILLIE">
+<span id="_CPPv3N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MILLIE"></span><span id="_CPPv2N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MILLIE"></span><span class="target" id="group__nanoarrow-utils_1gga7048580e7cf78a7d6baac47a6b39e1aca63ca1ac70e0f7da665d53091e355a6e7"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TIME_UNIT_MILLI</span></span></span><a class="headerlink" href="#_CPPv [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MICROE">
+<span id="_CPPv3N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MICROE"></span><span id="_CPPv2N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MICROE"></span><span class="target" id="group__nanoarrow-utils_1gga7048580e7cf78a7d6baac47a6b39e1aca1592fff76ca5a4dd006b9e7e375d2885"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TIME_UNIT_MICRO</span></span></span><a class="headerlink" href="#_CPPv [...]
+<dd></dd></dl>
+
+<dl class="cpp enumerator">
+<dt class="sig sig-object cpp" id="_CPPv4N13ArrowTimeUnit24NANOARROW_TIME_UNIT_NANOE">
+<span id="_CPPv3N13ArrowTimeUnit24NANOARROW_TIME_UNIT_NANOE"></span><span id="_CPPv2N13ArrowTimeUnit24NANOARROW_TIME_UNIT_NANOE"></span><span class="target" id="group__nanoarrow-utils_1gga7048580e7cf78a7d6baac47a6b39e1acaae0643d5e56d7feb6415a4b7cd36f2be"></span><span class="k"><span class="pre">enumerator</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_TIME_UNIT_NANO</span></span></span><a class="headerlink" href="#_CPPv4N1 [...]
+<dd></dd></dl>
+
+</dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv421ArrowNanoarrowVersionv">
+<span id="_CPPv321ArrowNanoarrowVersionv"></span><span id="_CPPv221ArrowNanoarrowVersionv"></span><span id="ArrowNanoarrowVersion__void"></span><span class="target" id="group__nanoarrow-utils_1ga8cd89898d227409d4fe013fabf2e4ea0"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span [...]
+<dd><p>Return a version string in the form “major.minor.patch”. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv424ArrowNanoarrowVersionIntv">
+<span id="_CPPv324ArrowNanoarrowVersionIntv"></span><span id="_CPPv224ArrowNanoarrowVersionIntv"></span><span id="ArrowNanoarrowVersionInt__void"></span><span class="target" id="group__nanoarrow-utils_1gaf84c127b20c1159f2ed777781f30c55c"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowNanoarrowVersionInt</span></span></span><span class="sig-paren">(</span><span class="kt"><span class [...]
+<dd><p>Return an integer that can be used to compare versions sequentially. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowLayoutInitP11ArrowLayout9ArrowType">
+<span id="_CPPv315ArrowLayoutInitP11ArrowLayout9ArrowType"></span><span id="_CPPv215ArrowLayoutInitP11ArrowLayout9ArrowType"></span><span id="ArrowLayoutInit__ArrowLayoutP.ArrowType"></span><span class="target" id="group__nanoarrow-utils_1gac1954fef441ad60b50e688b58ee04280"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowLayoutInit</span></span></span><span class="sig-paren">(</span [...]
+<dd><p>Initialize a description of buffer arrangements from a storage type. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv413ArrowCharViewPKc">
+<span id="_CPPv313ArrowCharViewPKc"></span><span id="_CPPv213ArrowCharViewPKc"></span><span id="ArrowCharView__cCP"></span><span class="target" id="group__nanoarrow-utils_1ga650e076b60473a35a18ff0bc52b51474"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv4 [...]
+<dd><p>Create a string view from a null-terminated string. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowTypeString9ArrowType">
+<span id="_CPPv315ArrowTypeString9ArrowType"></span><span id="_CPPv215ArrowTypeString9ArrowType"></span><span id="ArrowTypeString__ArrowType"></span><span class="target" id="group__nanoarrow-utils_1ga8912e1fb95c379d230b4723d362619cf"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt">< [...]
+<dd><p>Get a string value of an enum ArrowType value. </p>
+<p>Returns NULL for invalid values for type </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv419ArrowTimeUnitString13ArrowTimeUnit">
+<span id="_CPPv319ArrowTimeUnitString13ArrowTimeUnit"></span><span id="_CPPv219ArrowTimeUnitString13ArrowTimeUnit"></span><span id="ArrowTimeUnitString__ArrowTimeUnit"></span><span class="target" id="group__nanoarrow-utils_1ga13a80e043c8d5b2cb6c045dfb117d282"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="k"><span class="pre">const</span></span><span class="w"> [...]
+<dd><p>Get a string value of an enum ArrowTimeUnit value. </p>
+<p>Returns NULL for invalid values for time_unit </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowDecimalInitP12ArrowDecimal7int32_t7int32_t7int32_t">
+<span id="_CPPv316ArrowDecimalInitP12ArrowDecimal7int32_t7int32_t7int32_t"></span><span id="_CPPv216ArrowDecimalInitP12ArrowDecimal7int32_t7int32_t7int32_t"></span><span id="ArrowDecimalInit__ArrowDecimalP.int32_t.int32_t.int32_t"></span><span class="target" id="group__nanoarrow-utils_1ga07178a7a7ccc9339d129d717bcec88c9"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span [...]
+<dd><p>Initialize a decimal with a given set of type parameters. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowDecimalGetBytesP12ArrowDecimalP7uint8_t">
+<span id="_CPPv320ArrowDecimalGetBytesP12ArrowDecimalP7uint8_t"></span><span id="_CPPv220ArrowDecimalGetBytesP12ArrowDecimalP7uint8_t"></span><span id="ArrowDecimalGetBytes__ArrowDecimalP.uint8_tP"></span><span class="target" id="group__nanoarrow-utils_1gac9ec414fec12fc2890a182ed4ec242ab"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void [...]
+<dd><p>Copy the bytes of this decimal into a sufficiently large buffer. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowDecimalSignP12ArrowDecimal">
+<span id="_CPPv316ArrowDecimalSignP12ArrowDecimal"></span><span id="_CPPv216ArrowDecimalSignP12ArrowDecimal"></span><span id="ArrowDecimalSign__ArrowDecimalP"></span><span class="target" id="group__nanoarrow-utils_1gadd1d55f0df0cb4a119e1b4c8dc255170"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span [...]
+<dd><p>Returns 1 if the value represented by decimal is >= 0 or -1 otherwise. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv418ArrowDecimalSetIntP12ArrowDecimal7int64_t">
+<span id="_CPPv318ArrowDecimalSetIntP12ArrowDecimal7int64_t"></span><span id="_CPPv218ArrowDecimalSetIntP12ArrowDecimal7int64_t"></span><span id="ArrowDecimalSetInt__ArrowDecimalP.int64_t"></span><span class="target" id="group__nanoarrow-utils_1gad67d62564afed7c66c0c304cc87e63f0"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></ [...]
+<dd><p>Sets the integer value of this decimal. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowDecimalSetBytesP12ArrowDecimalPK7uint8_t">
+<span id="_CPPv320ArrowDecimalSetBytesP12ArrowDecimalPK7uint8_t"></span><span id="_CPPv220ArrowDecimalSetBytesP12ArrowDecimalPK7uint8_t"></span><span id="ArrowDecimalSetBytes__ArrowDecimalP.uint8_tCP"></span><span class="target" id="group__nanoarrow-utils_1gae1a97e4544e59f2c381f1f1cd5351a33"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">v [...]
+<dd><p>Copy bytes from a buffer into this decimal. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowStringView">
+<span id="_CPPv315ArrowStringView"></span><span id="_CPPv215ArrowStringView"></span><span id="ArrowStringView"></span><span class="target" id="struct_arrow_string_view"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowStringView</span></span></span><a class="headerlink" href="#_CPPv415ArrowStringView" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>An non-owning view of a string. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowStringView4dataE">
+<span id="_CPPv3N15ArrowStringView4dataE"></span><span id="_CPPv2N15ArrowStringView4dataE"></span><span id="ArrowStringView::data__cCP"></span><span class="target" id="struct_arrow_string_view_1ac063e6ca50dee2c35f762b849ec286a4"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span [...]
+<dd><p>A pointer to the start of the string. </p>
+<p>If size_bytes is 0, this value may be NULL. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowStringView10size_bytesE">
+<span id="_CPPv3N15ArrowStringView10size_bytesE"></span><span id="_CPPv2N15ArrowStringView10size_bytesE"></span><span id="ArrowStringView::size_bytes__int64_t"></span><span class="target" id="struct_arrow_string_view_1a7029f7770d54728f6c94a148c8d2524a"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">size_bytes</span></span></span><a class="headerlink" href="#_CPPv4N15ArrowStringView10s [...]
+<dd><p>The size of the string in bytes,. </p>
+<p>(Not including the null terminator.) </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowBufferView">
+<span id="_CPPv315ArrowBufferView"></span><span id="_CPPv215ArrowBufferView"></span><span id="ArrowBufferView"></span><span class="target" id="struct_arrow_buffer_view"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowBufferView</span></span></span><a class="headerlink" href="#_CPPv415ArrowBufferView" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>An non-owning view of a buffer. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferView4dataE">
+<span id="_CPPv3N15ArrowBufferView4dataE"></span><span id="_CPPv2N15ArrowBufferView4dataE"></span><span id="ArrowBufferView::data__ArrowBufferViewData"></span><span class="target" id="struct_arrow_buffer_view_1a0eb1861e51c3d44a79449841abdff7cf"></span><span class="k"><span class="pre">union</span></span><span class="w"> </span><span class="n"><span class="pre">ArrowBufferViewData</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">data</ [...]
+<dd><p>A pointer to the start of the buffer. </p>
+<p>If size_bytes is 0, this value may be NULL. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N15ArrowBufferView10size_bytesE">
+<span id="_CPPv3N15ArrowBufferView10size_bytesE"></span><span id="_CPPv2N15ArrowBufferView10size_bytesE"></span><span id="ArrowBufferView::size_bytes__int64_t"></span><span class="target" id="struct_arrow_buffer_view_1a5972c1506e89f78d2b672ceef2ef5350"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">size_bytes</span></span></span><a class="headerlink" href="#_CPPv4N15ArrowBufferView10s [...]
+<dd><p>The size of the buffer in bytes. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowLayout">
+<span id="_CPPv311ArrowLayout"></span><span id="_CPPv211ArrowLayout"></span><span id="ArrowLayout"></span><span class="target" id="struct_arrow_layout"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowLayout</span></span></span><a class="headerlink" href="#_CPPv411ArrowLayout" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>A description of an arrangement of buffers. </p>
+<p>Contains the minimum amount of information required to calculate the size of each buffer in an <a class="reference internal" href="#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> knowing only the length and offset of the array. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowLayout11buffer_typeE">
+<span id="_CPPv3N11ArrowLayout11buffer_typeE"></span><span id="_CPPv2N11ArrowLayout11buffer_typeE"></span><span id="ArrowLayout::buffer_type__ArrowBufferTypeA"></span><span class="target" id="struct_arrow_layout_1a4b4ab80af5f99668e1a7bd169795c381"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv415ArrowBufferType" title="ArrowBufferType"><span class="n"><span class="pre">ArrowBufferType</span></span></a><span cl [...]
+<dd><p>The function of each buffer. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowLayout16buffer_data_typeE">
+<span id="_CPPv3N11ArrowLayout16buffer_data_typeE"></span><span id="_CPPv2N11ArrowLayout16buffer_data_typeE"></span><span id="ArrowLayout::buffer_data_type__ArrowTypeA"></span><span class="target" id="struct_arrow_layout_1a3f509e3ed357c99fec7411bf2da9cecf"></span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv49ArrowType" title="ArrowType"><span class="n"><span class="pre">ArrowType</span></span></a><span class="w"> < [...]
+<dd><p>The data type of each buffer. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowLayout17element_size_bitsE">
+<span id="_CPPv3N11ArrowLayout17element_size_bitsE"></span><span id="_CPPv2N11ArrowLayout17element_size_bitsE"></span><span id="ArrowLayout::element_size_bits__int64_tA"></span><span class="target" id="struct_arrow_layout_1aa6dec63c922194420378784419e00cd5"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">element_size_bits</span></span></span><span class="p"><span class="pre">[</span></ [...]
+<dd><p>The size of an element each buffer or 0 if this size is variable or unknown. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowLayout19child_size_elementsE">
+<span id="_CPPv3N11ArrowLayout19child_size_elementsE"></span><span id="_CPPv2N11ArrowLayout19child_size_elementsE"></span><span id="ArrowLayout::child_size_elements__int64_t"></span><span class="target" id="struct_arrow_layout_1a3029a338b3c716c3f7ddadada280c880"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">child_size_elements</span></span></span><a class="headerlink" href="#_CPPv4N1 [...]
+<dd><p>The number of elements in the child array per element in this array for a fixed-size list. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv412ArrowDecimal">
+<span id="_CPPv312ArrowDecimal"></span><span id="_CPPv212ArrowDecimal"></span><span id="ArrowDecimal"></span><span class="target" id="struct_arrow_decimal"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowDecimal</span></span></span><a class="headerlink" href="#_CPPv412ArrowDecimal" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="docutils container">
+<em>#include <nanoarrow_types.h></em></div>
+<p>A representation of a fixed-precision decimal number. </p>
+<p>This structure should be initialized with ArrowDecimalInit() once and values set using ArrowDecimalSetInt(), ArrowDecimalSetBytes128(), or ArrowDecimalSetBytes256(). </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal5wordsE">
+<span id="_CPPv3N12ArrowDecimal5wordsE"></span><span id="_CPPv2N12ArrowDecimal5wordsE"></span><span id="ArrowDecimal::words__uint64_tA"></span><span class="target" id="struct_arrow_decimal_1aca665738c134dae7f1cb545b48d1ebb8"></span><span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">words</span></span></span><span class="p"><span class="pre">[</span></span><span class="m"><span class="pre">4</sp [...]
+<dd><p>An array of 64-bit integers of n_words length defined in native-endian order. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal9precisionE">
+<span id="_CPPv3N12ArrowDecimal9precisionE"></span><span id="_CPPv2N12ArrowDecimal9precisionE"></span><span id="ArrowDecimal::precision__int32_t"></span><span class="target" id="struct_arrow_decimal_1a7784aa2189b67dd479ab3cee0044d2ba"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">precision</span></span></span><a class="headerlink" href="#_CPPv4N12ArrowDecimal9precisionE" title="Perma [...]
+<dd><p>The number of significant digits this decimal number can represent. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal5scaleE">
+<span id="_CPPv3N12ArrowDecimal5scaleE"></span><span id="_CPPv2N12ArrowDecimal5scaleE"></span><span id="ArrowDecimal::scale__int32_t"></span><span class="target" id="struct_arrow_decimal_1aa88bae3df5964afb34cd012ccdff1970"></span><span class="n"><span class="pre">int32_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">scale</span></span></span><a class="headerlink" href="#_CPPv4N12ArrowDecimal5scaleE" title="Permalink to this definit [...]
+<dd><p>The number of digits after the decimal point. This can be negative. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal7n_wordsE">
+<span id="_CPPv3N12ArrowDecimal7n_wordsE"></span><span id="_CPPv2N12ArrowDecimal7n_wordsE"></span><span id="ArrowDecimal::n_words__i"></span><span class="target" id="struct_arrow_decimal_1a6c70dd46548980ab26e411f6051c5e96"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">n_words</span></span></span><a class="headerlink" href="#_CPPv4N12ArrowDecimal7n_wordsE" title="Permalink to this defini [...]
+<dd><p>The number of words in the words array. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal15high_word_indexE">
+<span id="_CPPv3N12ArrowDecimal15high_word_indexE"></span><span id="_CPPv2N12ArrowDecimal15high_word_indexE"></span><span id="ArrowDecimal::high_word_index__i"></span><span class="target" id="struct_arrow_decimal_1a1d8e73ef1240fd6f3e2fecdb48d9a15a"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">high_word_index</span></span></span><a class="headerlink" href="#_CPPv4N12ArrowDecimal15high_w [...]
+<dd><p>Cached value used by the implementation. </p>
+</dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N12ArrowDecimal14low_word_indexE">
+<span id="_CPPv3N12ArrowDecimal14low_word_indexE"></span><span id="_CPPv2N12ArrowDecimal14low_word_indexE"></span><span id="ArrowDecimal::low_word_index__i"></span><span class="target" id="struct_arrow_decimal_1a6e388c4f048137011236c914abc03241"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">low_word_index</span></span></span><a class="headerlink" href="#_CPPv4N12ArrowDecimal14low_word_i [...]
+<dd><p>Cached value used by the implementation. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="arrow-c-data-interface">
+<h2>Arrow C Data Interface<a class="headerlink" href="#arrow-c-data-interface" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow-arrow-cdata"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow-arrow-cdata</span></span></dt>
+<dd><p>The Arrow C Data (<a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">https://arrow.apache.org/docs/format/CDataInterface.html</a>) and Arrow C Stream (<a class="reference external" href="https://arrow.apache.org/docs/format/CStreamInterface.html">https://arrow.apache.org/docs/format/CStreamInterface.html</a>) interfaces are part of the Arrow Columnar Format specification (<a class="reference external" href="https://arrow.apache.org/docs/f [...]
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-defines">Defines</p>
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.ARROW_C_DATA_INTERFACE">
+<span class="target" id="group__nanoarrow-arrow-cdata_1ga62dff1b60bc389d2afc1f9845c8643c8"></span><span class="sig-name descname"><span class="n"><span class="pre">ARROW_C_DATA_INTERFACE</span></span></span><a class="headerlink" href="#c.ARROW_C_DATA_INTERFACE" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.ARROW_FLAG_DICTIONARY_ORDERED">
+<span class="target" id="group__nanoarrow-arrow-cdata_1gaeb5dd606ecbde0a6d99711756a6da1c1"></span><span class="sig-name descname"><span class="n"><span class="pre">ARROW_FLAG_DICTIONARY_ORDERED</span></span></span><a class="headerlink" href="#c.ARROW_FLAG_DICTIONARY_ORDERED" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.ARROW_FLAG_NULLABLE">
+<span class="target" id="group__nanoarrow-arrow-cdata_1ga5e08d487c628beadce561c5fd05ffab0"></span><span class="sig-name descname"><span class="n"><span class="pre">ARROW_FLAG_NULLABLE</span></span></span><a class="headerlink" href="#c.ARROW_FLAG_NULLABLE" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.ARROW_FLAG_MAP_KEYS_SORTED">
+<span class="target" id="group__nanoarrow-arrow-cdata_1ga4a8b190bb8b285f924648553ee468171"></span><span class="sig-name descname"><span class="n"><span class="pre">ARROW_FLAG_MAP_KEYS_SORTED</span></span></span><a class="headerlink" href="#c.ARROW_FLAG_MAP_KEYS_SORTED" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.ARROW_C_STREAM_INTERFACE">
+<span class="target" id="group__nanoarrow-arrow-cdata_1gaacad63acda264a0ae393bd842a77220d"></span><span class="sig-name descname"><span class="n"><span class="pre">ARROW_C_STREAM_INTERFACE</span></span></span><a class="headerlink" href="#c.ARROW_C_STREAM_INTERFACE" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+</div>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415ArrowSchemaMoveP11ArrowSchemaP11ArrowSchema">
+<span id="_CPPv315ArrowSchemaMoveP11ArrowSchemaP11ArrowSchema"></span><span id="_CPPv215ArrowSchemaMoveP11ArrowSchemaP11ArrowSchema"></span><span id="ArrowSchemaMove__ArrowSchemaP.ArrowSchemaP"></span><span class="target" id="group__nanoarrow-arrow-cdata_1ga2f542d961ad0e13e674c5b2345bf362f"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">vo [...]
+<dd><p>Move the contents of src into dst and set src->release to NULL. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv414ArrowArrayMoveP10ArrowArrayP10ArrowArray">
+<span id="_CPPv314ArrowArrayMoveP10ArrowArrayP10ArrowArray"></span><span id="_CPPv214ArrowArrayMoveP10ArrowArrayP10ArrowArray"></span><span id="ArrowArrayMove__ArrowArrayP.ArrowArrayP"></span><span class="target" id="group__nanoarrow-arrow-cdata_1gaa5e58db4cb7963924bebd14c6b6e8a20"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span> [...]
+<dd><p>Move the contents of src into dst and set src->release to NULL. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv420ArrowArrayStreamMoveP16ArrowArrayStreamP16ArrowArrayStream">
+<span id="_CPPv320ArrowArrayStreamMoveP16ArrowArrayStreamP16ArrowArrayStream"></span><span id="_CPPv220ArrowArrayStreamMoveP16ArrowArrayStreamP16ArrowArrayStream"></span><span id="ArrowArrayStreamMove__ArrowArrayStreamP.ArrowArrayStreamP"></span><span class="target" id="group__nanoarrow-arrow-cdata_1ga3b7b6acd65e9978c810b7776457864c6"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> [...]
+<dd><p>Move the contents of src into dst and set src->release to NULL. </p>
+</dd></dl>
+
+</div>
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv411ArrowSchema">
+<span id="_CPPv311ArrowSchema"></span><span id="_CPPv211ArrowSchema"></span><span id="ArrowSchema"></span><span class="target" id="struct_arrow_schema"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowSchema</span></span></span><a class="headerlink" href="#_CPPv411ArrowSchema" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema6formatE">
+<span id="_CPPv3N11ArrowSchema6formatE"></span><span id="_CPPv2N11ArrowSchema6formatE"></span><span id="ArrowSchema::format__cCP"></span><span class="target" id="struct_arrow_schema_1ab5d0127ee66cd298683f2a2d2aae5788"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema4nameE">
+<span id="_CPPv3N11ArrowSchema4nameE"></span><span id="_CPPv2N11ArrowSchema4nameE"></span><span id="ArrowSchema::name__cCP"></span><span class="target" id="struct_arrow_schema_1aa6dae1b0e311f4b30a9e2ca002ad8d22"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">name [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema8metadataE">
+<span id="_CPPv3N11ArrowSchema8metadataE"></span><span id="_CPPv2N11ArrowSchema8metadataE"></span><span id="ArrowSchema::metadata__cCP"></span><span class="target" id="struct_arrow_schema_1a51ceb37c71e94fac6b6e14a3d8e3b50c"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span clas [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema5flagsE">
+<span id="_CPPv3N11ArrowSchema5flagsE"></span><span id="_CPPv2N11ArrowSchema5flagsE"></span><span id="ArrowSchema::flags__int64_t"></span><span class="target" id="struct_arrow_schema_1a15b2e390fc6708b23ad29c69e136163c"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">flags</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowSchema5flagsE" title="Permalink to this definition"> [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema10n_childrenE">
+<span id="_CPPv3N11ArrowSchema10n_childrenE"></span><span id="_CPPv2N11ArrowSchema10n_childrenE"></span><span id="ArrowSchema::n_children__int64_t"></span><span class="target" id="struct_arrow_schema_1a88a53da5862c6d2f66692910ce5e5c42"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">n_children</span></span></span><a class="headerlink" href="#_CPPv4N11ArrowSchema10n_childrenE" title="Pe [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema8childrenE">
+<span id="_CPPv3N11ArrowSchema8childrenE"></span><span id="_CPPv2N11ArrowSchema8childrenE"></span><span id="ArrowSchema::children__ArrowSchemaPP"></span><span class="target" id="struct_arrow_schema_1ae0ba059e1e9a6879fc231f3475644c1a"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowSchema" title="ArrowSchema"><span class="n"><span class="pre">ArrowSchema</span></span></a><span class="w"> </span><span cl [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema10dictionaryE">
+<span id="_CPPv3N11ArrowSchema10dictionaryE"></span><span id="_CPPv2N11ArrowSchema10dictionaryE"></span><span id="ArrowSchema::dictionary__ArrowSchemaP"></span><span class="target" id="struct_arrow_schema_1ac608367ec75500cd6322cf6bf45bc4cf"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv411ArrowSchema" title="ArrowSchema"><span class="n"><span class="pre">ArrowSchema</span></span></a><span class="w"> </span>< [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema7releaseE">
+<span id="_CPPv3N11ArrowSchema7releaseE"></span><span id="_CPPv2N11ArrowSchema7releaseE"></span><span class="target" id="struct_arrow_schema_1ad471ae72074febbeaf80288f2f673c57"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">release</span></span></span><span class="p"><span class="pre">)</sp [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N11ArrowSchema12private_dataE">
+<span id="_CPPv3N11ArrowSchema12private_dataE"></span><span id="_CPPv2N11ArrowSchema12private_dataE"></span><span id="ArrowSchema::private_data__voidP"></span><span class="target" id="struct_arrow_schema_1ab385d6a15b6dc46194dcc4286f36b767"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">private_data</span></span></span><a class="headerlink [...]
+<dd></dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv410ArrowArray">
+<span id="_CPPv310ArrowArray"></span><span id="_CPPv210ArrowArray"></span><span id="ArrowArray"></span><span class="target" id="struct_arrow_array"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArray</span></span></span><a class="headerlink" href="#_CPPv410ArrowArray" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray6lengthE">
+<span id="_CPPv3N10ArrowArray6lengthE"></span><span id="_CPPv2N10ArrowArray6lengthE"></span><span id="ArrowArray::length__int64_t"></span><span class="target" id="struct_arrow_array_1ad36c74977f20ab8dbb3c6273e30a6719"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">length</span></span></span><a class="headerlink" href="#_CPPv4N10ArrowArray6lengthE" title="Permalink to this definition"> [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray10null_countE">
+<span id="_CPPv3N10ArrowArray10null_countE"></span><span id="_CPPv2N10ArrowArray10null_countE"></span><span id="ArrowArray::null_count__int64_t"></span><span class="target" id="struct_arrow_array_1a49fbb08c99e0f8d2a68c2f3a24aa2a76"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">null_count</span></span></span><a class="headerlink" href="#_CPPv4N10ArrowArray10null_countE" title="Permali [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray6offsetE">
+<span id="_CPPv3N10ArrowArray6offsetE"></span><span id="_CPPv2N10ArrowArray6offsetE"></span><span id="ArrowArray::offset__int64_t"></span><span class="target" id="struct_arrow_array_1aa1b045f8e085dbca894bb9c3900c007e"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">offset</span></span></span><a class="headerlink" href="#_CPPv4N10ArrowArray6offsetE" title="Permalink to this definition"> [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray9n_buffersE">
+<span id="_CPPv3N10ArrowArray9n_buffersE"></span><span id="_CPPv2N10ArrowArray9n_buffersE"></span><span id="ArrowArray::n_buffers__int64_t"></span><span class="target" id="struct_arrow_array_1acb8b049eef21583b2f9f650d36fff2f6"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">n_buffers</span></span></span><a class="headerlink" href="#_CPPv4N10ArrowArray9n_buffersE" title="Permalink to th [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray10n_childrenE">
+<span id="_CPPv3N10ArrowArray10n_childrenE"></span><span id="_CPPv2N10ArrowArray10n_childrenE"></span><span id="ArrowArray::n_children__int64_t"></span><span class="target" id="struct_arrow_array_1a39a2697ceead3e08c0b89339c2aacb37"></span><span class="n"><span class="pre">int64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">n_children</span></span></span><a class="headerlink" href="#_CPPv4N10ArrowArray10n_childrenE" title="Permali [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray7buffersE">
+<span id="_CPPv3N10ArrowArray7buffersE"></span><span id="_CPPv2N10ArrowArray7buffersE"></span><span id="ArrowArray::buffers__voidCPP"></span><span class="target" id="struct_arrow_array_1aa6766338a7beb165e32255cbd641f569"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">*</span></span><span class= [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray8childrenE">
+<span id="_CPPv3N10ArrowArray8childrenE"></span><span id="_CPPv2N10ArrowArray8childrenE"></span><span id="ArrowArray::children__ArrowArrayPP"></span><span class="target" id="struct_arrow_array_1a4fb07be9899001e57c9ab0509396ffb8"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv410ArrowArray" title="ArrowArray"><span class="n"><span class="pre">ArrowArray</span></span></a><span class="w"> </span><span class="p"> [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray10dictionaryE">
+<span id="_CPPv3N10ArrowArray10dictionaryE"></span><span id="_CPPv2N10ArrowArray10dictionaryE"></span><span id="ArrowArray::dictionary__ArrowArrayP"></span><span class="target" id="struct_arrow_array_1aa4b987f9f4c600b5accc9830006b4da8"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv410ArrowArray" title="ArrowArray"><span class="n"><span class="pre">ArrowArray</span></span></a><span class="w"> </span><span cla [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray7releaseE">
+<span id="_CPPv3N10ArrowArray7releaseE"></span><span id="_CPPv2N10ArrowArray7releaseE"></span><span class="target" id="struct_arrow_array_1a03ad36422f651c0b0ccd9ab9c5b7d5d3"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">release</span></span></span><span class="p"><span class="pre">)</span> [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N10ArrowArray12private_dataE">
+<span id="_CPPv3N10ArrowArray12private_dataE"></span><span id="_CPPv2N10ArrowArray12private_dataE"></span><span id="ArrowArray::private_data__voidP"></span><span class="target" id="struct_arrow_array_1a1f2d5a334bb41924c4822bbfc7aec63e"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">private_data</span></span></span><a class="headerlink" hr [...]
+<dd></dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp struct">
+<dt class="sig sig-object cpp" id="_CPPv416ArrowArrayStream">
+<span id="_CPPv316ArrowArrayStream"></span><span id="_CPPv216ArrowArrayStream"></span><span id="ArrowArrayStream"></span><span class="target" id="struct_arrow_array_stream"></span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ArrowArrayStream</span></span></span><a class="headerlink" href="#_CPPv416ArrowArrayStream" title="Permalink to this definition">#</a><br /></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-members">Public Members</p>
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N16ArrowArrayStream10get_schemaE">
+<span id="_CPPv3N16ArrowArrayStream10get_schemaE"></span><span id="_CPPv2N16ArrowArrayStream10get_schemaE"></span><span class="target" id="struct_arrow_array_stream_1ae3a7b23fdfe446a3d095342c39d981c9"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">get_schema</span></span></span><span class=" [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N16ArrowArrayStream8get_nextE">
+<span id="_CPPv3N16ArrowArrayStream8get_nextE"></span><span id="_CPPv2N16ArrowArrayStream8get_nextE"></span><span class="target" id="struct_arrow_array_stream_1a13f0d5da2fc463ce35463757ddb5d36e"></span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">get_next</span></span></span><span class="p"><span [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N16ArrowArrayStream14get_last_errorE">
+<span id="_CPPv3N16ArrowArrayStream14get_last_errorE"></span><span id="_CPPv2N16ArrowArrayStream14get_last_errorE"></span><span class="target" id="struct_arrow_array_stream_1a7268c69a6b60a4ba9a9bbff1f4b87664"></span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">(</span></span><span class="p"><span cl [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N16ArrowArrayStream7releaseE">
+<span id="_CPPv3N16ArrowArrayStream7releaseE"></span><span id="_CPPv2N16ArrowArrayStream7releaseE"></span><span class="target" id="struct_arrow_array_stream_1a7fe27fba0eed01ed6f63591b22c6b859"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">(</span></span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">release</span></span></span><span class="p"><span c [...]
+<dd></dd></dl>
+
+<dl class="cpp var">
+<dt class="sig sig-object cpp" id="_CPPv4N16ArrowArrayStream12private_dataE">
+<span id="_CPPv3N16ArrowArrayStream12private_dataE"></span><span id="_CPPv2N16ArrowArrayStream12private_dataE"></span><span id="ArrowArrayStream::private_data__voidP"></span><span class="target" id="struct_arrow_array_stream_1a35d4fb572d51736c6c447f64406b50d9"></span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">private_data</span></span></span [...]
+<dd></dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+</section>
+
+
+ </article>
+
+
+
+ <footer class="bd-footer-article">
+
+<div class="footer-article-items footer-article__inner">
+
+ <div class="footer-article-item"><!-- Previous / next buttons -->
+<div class="prev-next-area">
+ <a class="left-prev"
+ href="getting-started.html"
+ title="previous page">
+ <i class="fa-solid fa-angle-left"></i>
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">previous</p>
+ <p class="prev-next-title">Getting started with nanoarrow</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="cpp.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">C++ API Reference</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div></div>
+
+</div>
+
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+ <div class="sidebar-secondary-item">
+ <div class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#creating-schemas">Creating schemas</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#reading-schemas">Reading schemas</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#creating-arrays">Creating arrays</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#reading-arrays">Reading arrays</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#owning-growable-buffers">Owning, growable buffers</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#bitmap-utilities">Bitmap utilities</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#create-read-and-modify-schema-metadata">Create, read, and modify schema metadata</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#memory-management">Memory management</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#error-handling">Error handling</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#utility-data-structures">Utility data structures</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrow-c-data-interface">Arrow C Data Interface</a></li>
+</ul>
+ </nav></div>
+
+ <div class="sidebar-secondary-item">
+
+ <div class="tocsection editthispage">
+ <a href="https://github.com/apache/arrow-nanoarrow/edit/main/docs/source/c.rst">
+ <i class="fa-solid fa-pencil"></i>
+
+
+
+ Edit on GitHub
+
+
+ </a>
+ </div>
+</div>
+
+ <div class="sidebar-secondary-item">
+ <div class="tocsection sourcelink">
+ <a href="_sources/c.rst.txt">
+ <i class="fa-solid fa-file-lines"></i> Show Source
+ </a>
+ </div>
+</div>
+
+</div></div>
+
+
+ </div>
+ <footer class="bd-footer-content">
+
+ </footer>
+
+ </main>
+ </div>
+ </div>
+
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="_static/scripts/bootstrap.js?digest=e353d410970836974a52"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52"></script>
+
+ <footer class="bd-footer">
+<div class="bd-footer__inner bd-page-width">
+
+ <div class="footer-items__start">
+
+ <div class="footer-item">
+ <p class="copyright">
+
+ © Copyright 2016-2023 Apache Software Foundation.
+ <br/>
+
+ </p>
+</div>
+
+ <div class="footer-item">
+ <p class="sphinx-version">
+ Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.0.1.
+ <br/>
+ </p>
+</div>
+
+ </div>
+
+
+ <div class="footer-items__end">
+
+ <div class="footer-item"><p class="theme-version">
+ Built with the <a href="https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html">PyData Sphinx Theme</a> 0.13.3.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/0.2.0/cpp.html b/0.2.0/cpp.html
new file mode 100644
index 0000000..ae00136
--- /dev/null
+++ b/0.2.0/cpp.html
@@ -0,0 +1,797 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+
+ <title>C++ API Reference — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'cpp';</script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="IPC Extension Reference" href="ipc.html" />
+ <link rel="prev" title="C API Reference" href="c.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="index.html">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+ <div class="navbar-header-items__end">
+
+ <div class="navbar-item navbar-persistent--container">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </nav>
+
+ <div class="bd-container">
+ <div class="bd-container__inner bd-page-width">
+
+ <div class="bd-sidebar-primary bd-sidebar">
+
+
+
+ <div class="sidebar-header-items sidebar-primary__section">
+
+
+ <div class="sidebar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+ <div class="sidebar-primary-items__start sidebar-primary__section">
+ <div class="sidebar-primary-item">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+
+ <div class="sidebar-primary-items__end sidebar-primary__section">
+ </div>
+
+ <div id="rtd-footer-container"></div>
+
+
+ </div>
+
+ <main id="main-content" class="bd-main">
+
+
+ <div class="bd-content">
+ <div class="bd-article-container">
+
+ <div class="bd-header-article">
+<div class="header-article-items header-article__inner">
+
+ <div class="header-article-items__start">
+
+ <div class="header-article-item">
+
+
+
+<nav aria-label="Breadcrumbs">
+ <ul class="bd-breadcrumbs" role="navigation" aria-label="Breadcrumb">
+
+ <li class="breadcrumb-item breadcrumb-home">
+ <a href="index.html" class="nav-link" aria-label="Home">
+ <i class="fa-solid fa-home"></i>
+ </a>
+ </li>
+ <li class="breadcrumb-item active" aria-current="page">C++ API Reference</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article" role="main">
+
+ <section id="c-api-reference">
+<h1>C++ API Reference<a class="headerlink" href="#c-api-reference" title="Permalink to this heading">#</a></h1>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow__hpp"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow_hpp</span></span></dt>
+<dd><p>The utilities provided in this file are intended to support C++ users of the nanoarrow C library such that C++-style resource allocation and error handling can be used with nanoarrow data structures. These utilities are not intended to mirror the nanoarrow C API. </p>
+</dd></dl>
+
+<section id="error-handling">
+<h2>Error handling<a class="headerlink" href="#error-handling" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow__hpp-errors"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow_hpp-errors</span></span></dt>
+<dd><p>Most functions in the C API return an ArrowErrorCode to communicate possible failure. Except where documented, it is usually not safe to continue after a non-zero value has been returned. While the nanoarrow C++ helpers do not throw any exceptions of their own, these helpers are provided to facilitate using the nanoarrow C++ helpers in frameworks where this is a useful error handling idiom. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-defines">Defines</p>
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c._NANOARROW_THROW_NOT_OK_IMPL">
+<span class="target" id="group__nanoarrow__hpp-errors_1gaafcc7dac6fcd1f00addabc7e248806c2"></span><span class="sig-name descname"><span class="n"><span class="pre">_NANOARROW_THROW_NOT_OK_IMPL</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">NAME</span></span>, <span class="n"><span class="pre">EXPR</span></span>, <span class="n"><span class="pre">EXPR_STR</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c._NANOARROW_THROW_NOT [...]
+<dd></dd></dl>
+
+<dl class="cpp macro">
+<dt class="sig sig-object cpp" id="c.NANOARROW_THROW_NOT_OK">
+<span class="target" id="group__nanoarrow__hpp-errors_1ga4b10c1b6dd5ccbe52087f1cf59475203"></span><span class="sig-name descname"><span class="n"><span class="pre">NANOARROW_THROW_NOT_OK</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">EXPR</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.NANOARROW_THROW_NOT_OK" title="Permalink to this definition">#</a><br /></dt>
+<dd></dd></dl>
+
+</div>
+<dl class="cpp class">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow9ExceptionE">
+<span id="_CPPv3N9nanoarrow9ExceptionE"></span><span id="_CPPv2N9nanoarrow9ExceptionE"></span><span id="nanoarrow::Exception"></span><span class="target" id="classnanoarrow_1_1_exception"></span><span class="k"><span class="pre">class</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">Exception</span></span></span><span class="w"> </span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="k"><span class [...]
+<dd></dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="owning-object-wrappers">
+<h2>Owning object wrappers<a class="headerlink" href="#owning-object-wrappers" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow__hpp-unique"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow_hpp-unique</span></span></dt>
+<dd><p>The Arrow C Data interface, the Arrow C Stream interface, and the nanoarrow C library use stack-allocatable objects, some of which require initialization or cleanup. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-typedefs">Typedefs</p>
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv412UniqueSchema">
+<span id="_CPPv312UniqueSchema"></span><span id="_CPPv212UniqueSchema"></span><span class="target" id="group__nanoarrow__hpp-unique_1ga912b1e6bbdeb87941b95cb4659e6ee6e"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueSchema</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class="pre">internal< [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv411UniqueArray">
+<span id="_CPPv311UniqueArray"></span><span id="_CPPv211UniqueArray"></span><span class="target" id="group__nanoarrow__hpp-unique_1ga93f47526e4b64c67ac0c2120cdd5a32a"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueArray</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class="pre">internal</sp [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv417UniqueArrayStream">
+<span id="_CPPv317UniqueArrayStream"></span><span id="_CPPv217UniqueArrayStream"></span><span class="target" id="group__nanoarrow__hpp-unique_1gaf77a45c6e828bc32ad9dda17467e2de6"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueArrayStream</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class= [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_array_stream"><span class="std std-ref">ArrowArrayStream</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv412UniqueBuffer">
+<span id="_CPPv312UniqueBuffer"></span><span id="_CPPv212UniqueBuffer"></span><span class="target" id="group__nanoarrow__hpp-unique_1gabc8af265788a5845e13ee5e7f2aaeb6d"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueBuffer</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class="pre">internal< [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_buffer"><span class="std std-ref">ArrowBuffer</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv412UniqueBitmap">
+<span id="_CPPv312UniqueBitmap"></span><span id="_CPPv212UniqueBitmap"></span><span class="target" id="group__nanoarrow__hpp-unique_1ga363de46854c2455c5849df0495f9a88b"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueBitmap</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class="pre">internal< [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_bitmap"><span class="std std-ref">ArrowBitmap</span></a>. </p>
+</dd></dl>
+
+<dl class="cpp type">
+<dt class="sig sig-object cpp" id="_CPPv415UniqueArrayView">
+<span id="_CPPv315UniqueArrayView"></span><span id="_CPPv215UniqueArrayView"></span><span class="target" id="group__nanoarrow__hpp-unique_1ga7171390b0258c15dee585010f9358e5b"></span><span class="k"><span class="pre">using</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">UniqueArrayView</span></span></span><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="n"><span class="pre"> [...]
+<dd><p>Class wrapping a unique struct <a class="reference internal" href="c.html#struct_arrow_array_view"><span class="std std-ref">ArrowArrayView</span></a>. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</section>
+<section id="array-stream-utilities">
+<h2>Array Stream utilities<a class="headerlink" href="#array-stream-utilities" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow__hpp-array-stream"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow_hpp-array-stream</span></span></dt>
+<dd><p>These classes provide simple struct <a class="reference internal" href="c.html#struct_arrow_array_stream"><span class="std std-ref">ArrowArrayStream</span></a> implementations that can be extended to help simplify the process of creating a valid <a class="reference internal" href="c.html#struct_arrow_array_stream"><span class="std std-ref">ArrowArrayStream</span></a> implementation or used as-is for testing. </p>
+<dl class="cpp class">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow16EmptyArrayStreamE">
+<span id="_CPPv3N9nanoarrow16EmptyArrayStreamE"></span><span id="_CPPv2N9nanoarrow16EmptyArrayStreamE"></span><span id="nanoarrow::EmptyArrayStream"></span><span class="target" id="classnanoarrow_1_1_empty_array_stream"></span><span class="k"><span class="pre">class</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">EmptyArrayStream</span></span></span><a class="headerlink" href="#_CPPv4N9nanoarrow16EmptyArrayStreamE" title="Permalink t [...]
+<dd><div class="docutils container">
+<em>#include <nanoarrow.hpp></em></div>
+<p>An empty array stream. </p>
+<p>This class can be constructed from an enum ArrowType or struct <a class="reference internal" href="c.html#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a> and implements a default get_next() method that always marks the output <a class="reference internal" href="c.html#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> as released. This class can be extended with an implementation of get_next() for a custom source. </p>
+<p>Subclassed by <a class="reference internal" href="#classnanoarrow_1_1_vector_array_stream"><span class="std std-ref">nanoarrow::VectorArrayStream</span></a></p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-static-functions">Public Static Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow16EmptyArrayStream10MakeUniqueEP11ArrowSchema">
+<span id="_CPPv3N9nanoarrow16EmptyArrayStream10MakeUniqueEP11ArrowSchema"></span><span id="_CPPv2N9nanoarrow16EmptyArrayStream10MakeUniqueEP11ArrowSchema"></span><span id="nanoarrow::EmptyArrayStream::MakeUnique__ArrowSchemaP"></span><span class="target" id="classnanoarrow_1_1_empty_array_stream_1abeb0b129442c5a78db5cf95fa380f066"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </s [...]
+<dd><p>Create an empty UniqueArrayStream from a struct <a class="reference internal" href="c.html#struct_arrow_schema"><span class="std std-ref">ArrowSchema</span></a>. </p>
+<p>This object takes ownership of the schema and marks the source schema as released. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+<dl class="cpp class">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow17VectorArrayStreamE">
+<span id="_CPPv3N9nanoarrow17VectorArrayStreamE"></span><span id="_CPPv2N9nanoarrow17VectorArrayStreamE"></span><span id="nanoarrow::VectorArrayStream"></span><span class="target" id="classnanoarrow_1_1_vector_array_stream"></span><span class="k"><span class="pre">class</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">VectorArrayStream</span></span></span><span class="w"> </span><span class="p"><span class="pre">:</span></span><span c [...]
+<dd><div class="docutils container">
+<em>#include <nanoarrow.hpp></em></div>
+<p>Implementation of an <a class="reference internal" href="c.html#struct_arrow_array_stream"><span class="std std-ref">ArrowArrayStream</span></a> backed by a vector of <a class="reference internal" href="c.html#struct_arrow_array"><span class="std std-ref">ArrowArray</span></a> objects. </p>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-static-functions">Public Static Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaP10ArrowArray">
+<span id="_CPPv3N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaP10ArrowArray"></span><span id="_CPPv2N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaP10ArrowArray"></span><span id="nanoarrow::VectorArrayStream::MakeUnique__ArrowSchemaP.ArrowArrayP"></span><span class="target" id="classnanoarrow_1_1_vector_array_stream_1ada8ae27d26108887f3ca63bf1db7c87a"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre [...]
+<dd><p>Create a UniqueArrowArrayStream from an existing array. </p>
+<p>Takes ownership of the schema and the array. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaNSt6vectorI11UniqueArrayEE">
+<span id="_CPPv3N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaNSt6vectorI11UniqueArrayEE"></span><span id="_CPPv2N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaNSt6vectorI11UniqueArrayEE"></span><span id="nanoarrow::VectorArrayStream::MakeUnique__ArrowSchemaP.std::vector:UniqueArray:"></span><span class="target" id="classnanoarrow_1_1_vector_array_stream_1a59fbc6edd7957bed81f5b82f791d8668"></span><span class="k"><span class="pre">static</span></span><span class="w"> [...]
+<dd><p>Create a UniqueArrowArrayStream from existing arrays. </p>
+<p>This object takes ownership of the schema and arrays. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+<section id="base-classes-and-utilities">
+<h2>Base classes and utilities<a class="headerlink" href="#base-classes-and-utilities" title="Permalink to this heading">#</a></h2>
+<dl>
+<dt class="sig sig-object cpp">
+<span class="target" id="group__nanoarrow__hpp-unique__base"></span><em><span class="pre">group</span></em> <span class="sig-name descname"><span class="pre">nanoarrow_hpp-unique_base</span></span></dt>
+<dd><div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-functions">Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP11ArrowSchema">
+<span id="_CPPv312init_pointerP11ArrowSchema"></span><span id="_CPPv212init_pointerP11ArrowSchema"></span><span id="init_pointer__ArrowSchemaP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1gac4aeb1701efac5f348b9d73c348159a4"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><spa [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP11ArrowSchemaP11ArrowSchema">
+<span id="_CPPv312move_pointerP11ArrowSchemaP11ArrowSchema"></span><span id="_CPPv212move_pointerP11ArrowSchemaP11ArrowSchema"></span><span id="move_pointer__ArrowSchemaP.ArrowSchemaP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga9ee5c8441d2dd6b4e93bfe4e9727697c"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void< [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP11ArrowSchema">
+<span id="_CPPv315release_pointerP11ArrowSchema"></span><span id="_CPPv215release_pointerP11ArrowSchema"></span><span id="release_pointer__ArrowSchemaP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga7df90210779a09d09a11cd9dbe7b6893"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </ [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP10ArrowArray">
+<span id="_CPPv312init_pointerP10ArrowArray"></span><span id="_CPPv212init_pointerP10ArrowArray"></span><span id="init_pointer__ArrowArrayP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga560e8a28f8e52d5c738753c497cd9d6c"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span c [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP10ArrowArrayP10ArrowArray">
+<span id="_CPPv312move_pointerP10ArrowArrayP10ArrowArray"></span><span id="_CPPv212move_pointerP10ArrowArrayP10ArrowArray"></span><span id="move_pointer__ArrowArrayP.ArrowArrayP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga1d2b6e53856f53e939c8f04146473d13"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span> [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP10ArrowArray">
+<span id="_CPPv315release_pointerP10ArrowArray"></span><span id="_CPPv215release_pointerP10ArrowArray"></span><span id="release_pointer__ArrowArrayP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga40a95fbafcea5081f24d71f5fe371c88"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </spa [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP16ArrowArrayStream">
+<span id="_CPPv312init_pointerP16ArrowArrayStream"></span><span id="_CPPv212init_pointerP16ArrowArrayStream"></span><span id="init_pointer__ArrowArrayStreamP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga69bf02bdb2db20e166b6d85dac993acf"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class=" [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP16ArrowArrayStreamP16ArrowArrayStream">
+<span id="_CPPv312move_pointerP16ArrowArrayStreamP16ArrowArrayStream"></span><span id="_CPPv212move_pointerP16ArrowArrayStreamP16ArrowArrayStream"></span><span id="move_pointer__ArrowArrayStreamP.ArrowArrayStreamP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1gaf551b40262fce6c49ae3758fecc0200a"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span clas [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP16ArrowArrayStream">
+<span id="_CPPv315release_pointerP16ArrowArrayStream"></span><span id="_CPPv215release_pointerP16ArrowArrayStream"></span><span id="release_pointer__ArrowArrayStreamP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga41e68b38c2836cbb96e1610c1adc6a22"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><spa [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP11ArrowBuffer">
+<span id="_CPPv312init_pointerP11ArrowBuffer"></span><span id="_CPPv212init_pointerP11ArrowBuffer"></span><span id="init_pointer__ArrowBufferP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga1ab1e6cd29eea84565ca8aa5418a566b"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><spa [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP11ArrowBufferP11ArrowBuffer">
+<span id="_CPPv312move_pointerP11ArrowBufferP11ArrowBuffer"></span><span id="_CPPv212move_pointerP11ArrowBufferP11ArrowBuffer"></span><span id="move_pointer__ArrowBufferP.ArrowBufferP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1gaeeb83d7db1e27fc677ed3f5d8d6b473b"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void< [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP11ArrowBuffer">
+<span id="_CPPv315release_pointerP11ArrowBuffer"></span><span id="_CPPv215release_pointerP11ArrowBuffer"></span><span id="release_pointer__ArrowBufferP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga748ba2bfaaeb5549655512989b1d74fd"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </ [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP11ArrowBitmap">
+<span id="_CPPv312init_pointerP11ArrowBitmap"></span><span id="_CPPv212init_pointerP11ArrowBitmap"></span><span id="init_pointer__ArrowBitmapP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1gaf95f898990fafeecb5353028f17810fd"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><spa [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP11ArrowBitmapP11ArrowBitmap">
+<span id="_CPPv312move_pointerP11ArrowBitmapP11ArrowBitmap"></span><span id="_CPPv212move_pointerP11ArrowBitmapP11ArrowBitmap"></span><span id="move_pointer__ArrowBitmapP.ArrowBitmapP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga725860c9de0ace4de99af63a724eeac3"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void< [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP11ArrowBitmap">
+<span id="_CPPv315release_pointerP11ArrowBitmap"></span><span id="_CPPv215release_pointerP11ArrowBitmap"></span><span id="release_pointer__ArrowBitmapP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga1baf23f447836e06300cc77225af88b1"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </ [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412init_pointerP14ArrowArrayView">
+<span id="_CPPv312init_pointerP14ArrowArrayView"></span><span id="_CPPv212init_pointerP14ArrowArrayView"></span><span id="init_pointer__ArrowArrayViewP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1gaf1154790a4a0402506faf6cdf5df42db"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </ [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv412move_pointerP14ArrowArrayViewP14ArrowArrayView">
+<span id="_CPPv312move_pointerP14ArrowArrayViewP14ArrowArrayView"></span><span id="_CPPv212move_pointerP14ArrowArrayViewP14ArrowArrayView"></span><span id="move_pointer__ArrowArrayViewP.ArrowArrayViewP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga9211cbe1dcf411822220acb7955703cd"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span [...]
+<dd></dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv415release_pointerP14ArrowArrayView">
+<span id="_CPPv315release_pointerP14ArrowArrayView"></span><span id="_CPPv215release_pointerP14ArrowArrayView"></span><span id="release_pointer__ArrowArrayViewP"></span><span class="target" id="group__nanoarrow__hpp-unique__base_1ga80b7e180e5d2f661427efc290e60e0f1"></span><span class="k"><span class="pre">static</span></span><span class="w"> </span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span clas [...]
+<dd></dd></dl>
+
+</div>
+<dl class="cpp class">
+<dt class="sig sig-object cpp" id="_CPPv4I0EN9nanoarrow8internal6UniqueE">
+<span id="_CPPv3I0EN9nanoarrow8internal6UniqueE"></span><span id="_CPPv2I0EN9nanoarrow8internal6UniqueE"></span><span class="k"><span class="pre">template</span></span><span class="p"><span class="pre"><</span></span><span class="k"><span class="pre">typename</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">T</span></span></span><span class="p"><span class="pre">></span></span><br /><span class="target" id="classnanoarrow_1_1int [...]
+<dd><div class="docutils container">
+<em>#include <nanoarrow.hpp></em></div>
+<p>A unique_ptr-like base class for stack-allocatable objects. </p>
+<dl class="field-list simple">
+<dt class="field-odd">Template Parameters<span class="colon">:</span></dt>
+<dd class="field-odd"><p><strong>T</strong> – The object type </p>
+</dd>
+</dl>
+<div class="breathe-sectiondef docutils container">
+<p class="breathe-sectiondef-title rubric" id="breathe-section-title-public-functions">Public Functions</p>
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique6UniqueEv">
+<span id="_CPPv3N9nanoarrow8internal6Unique6UniqueEv"></span><span id="_CPPv2N9nanoarrow8internal6Unique6UniqueEv"></span><span id="nanoarrow::internal::Unique::Unique"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a004ae4a4a8deaaca56f73d33b13318da"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">Unique</span></span></span><span class="sig-paren">(</span><span c [...]
+<dd><p>Construct an invalid instance of T holding no resources. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique6UniqueEP1T">
+<span id="_CPPv3N9nanoarrow8internal6Unique6UniqueEP1T"></span><span id="_CPPv2N9nanoarrow8internal6Unique6UniqueEP1T"></span><span id="nanoarrow::internal::Unique::Unique__TP"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a6903dc88ef1791497cfbe9c63ef974ca"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">Unique</span></span></span><span class="sig-paren">(</span [...]
+<dd><p>Move and take ownership of data. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique6UniqueERR6Unique">
+<span id="_CPPv3N9nanoarrow8internal6Unique6UniqueERR6Unique"></span><span id="_CPPv2N9nanoarrow8internal6Unique6UniqueERR6Unique"></span><span id="nanoarrow::internal::Unique::Unique__UniqueRR"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a8bd291672a60ebf756a1ef6eca9240b6"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">Unique</span></span></span><span class=" [...]
+<dd><p>Move and take ownership of data wrapped by rhs. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique3getEv">
+<span id="_CPPv3N9nanoarrow8internal6Unique3getEv"></span><span id="_CPPv2N9nanoarrow8internal6Unique3getEv"></span><span id="nanoarrow::internal::Unique::get"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1ae3a985823191b160cb83b84b4a7e2464"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv4I0EN9nanoarrow8internal6UniqueE" title="nanoarrow::internal::Unique::T"><span class="n"><span clas [...]
+<dd><p>Get a pointer to the data owned by this object. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6UniqueptEv">
+<span id="_CPPv3N9nanoarrow8internal6UniqueptEv"></span><span id="_CPPv2N9nanoarrow8internal6UniqueptEv"></span><span id="nanoarrow::internal::Unique::pointer-operator"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a94c70b2e6027be26c1c33edc50bfad77"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><a class="reference internal" href="#_CPPv4I0EN9nanoarrow8internal6UniqueE" title="nanoarrow::internal::Unique::T"><span class="n">< [...]
+<dd><p>Use the pointer operator to access fields of this object. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique5resetEv">
+<span id="_CPPv3N9nanoarrow8internal6Unique5resetEv"></span><span id="_CPPv2N9nanoarrow8internal6Unique5resetEv"></span><span id="nanoarrow::internal::Unique::reset"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1aa1f589b25d78be96d1d82bd52e9f78f7"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span clas [...]
+<dd><p>Call data’s release callback if valid. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique5resetEP1T">
+<span id="_CPPv3N9nanoarrow8internal6Unique5resetEP1T"></span><span id="_CPPv2N9nanoarrow8internal6Unique5resetEP1T"></span><span id="nanoarrow::internal::Unique::reset__TP"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a4fdcf72051df5b44b249d4916043057e"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><s [...]
+<dd><p>Call data’s release callback if valid and move ownership of the data pointed to by data. </p>
+</dd></dl>
+
+<dl class="cpp function">
+<dt class="sig sig-object cpp" id="_CPPv4N9nanoarrow8internal6Unique4moveEP1T">
+<span id="_CPPv3N9nanoarrow8internal6Unique4moveEP1T"></span><span id="_CPPv2N9nanoarrow8internal6Unique4moveEP1T"></span><span id="nanoarrow::internal::Unique::move__TP"></span><span class="target" id="classnanoarrow_1_1internal_1_1_unique_1a38b63f427f4e78b3d14f8bb1c8ce6574"></span><span class="k"><span class="pre">inline</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span [...]
+<dd><p>Move ownership of this object to the data pointed to by out. </p>
+</dd></dl>
+
+</div>
+</dd></dl>
+
+</dd></dl>
+
+</section>
+</section>
+
+
+ </article>
+
+
+
+ <footer class="bd-footer-article">
+
+<div class="footer-article-items footer-article__inner">
+
+ <div class="footer-article-item"><!-- Previous / next buttons -->
+<div class="prev-next-area">
+ <a class="left-prev"
+ href="c.html"
+ title="previous page">
+ <i class="fa-solid fa-angle-left"></i>
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">previous</p>
+ <p class="prev-next-title">C API Reference</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="ipc.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">IPC Extension Reference</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div></div>
+
+</div>
+
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+ <div class="sidebar-secondary-item">
+ <div class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#error-handling">Error handling</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#owning-object-wrappers">Owning object wrappers</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#array-stream-utilities">Array Stream utilities</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#base-classes-and-utilities">Base classes and utilities</a></li>
+</ul>
+ </nav></div>
+
+ <div class="sidebar-secondary-item">
+
+ <div class="tocsection editthispage">
+ <a href="https://github.com/apache/arrow-nanoarrow/edit/main/docs/source/cpp.rst">
+ <i class="fa-solid fa-pencil"></i>
+
+
+
+ Edit on GitHub
+
+
+ </a>
+ </div>
+</div>
+
+ <div class="sidebar-secondary-item">
+ <div class="tocsection sourcelink">
+ <a href="_sources/cpp.rst.txt">
+ <i class="fa-solid fa-file-lines"></i> Show Source
+ </a>
+ </div>
+</div>
+
+</div></div>
+
+
+ </div>
+ <footer class="bd-footer-content">
+
+ </footer>
+
+ </main>
+ </div>
+ </div>
+
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="_static/scripts/bootstrap.js?digest=e353d410970836974a52"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52"></script>
+
+ <footer class="bd-footer">
+<div class="bd-footer__inner bd-page-width">
+
+ <div class="footer-items__start">
+
+ <div class="footer-item">
+ <p class="copyright">
+
+ © Copyright 2016-2023 Apache Software Foundation.
+ <br/>
+
+ </p>
+</div>
+
+ <div class="footer-item">
+ <p class="sphinx-version">
+ Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.0.1.
+ <br/>
+ </p>
+</div>
+
+ </div>
+
+
+ <div class="footer-items__end">
+
+ <div class="footer-item"><p class="theme-version">
+ Built with the <a href="https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html">PyData Sphinx Theme</a> 0.13.3.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/0.2.0/genindex.html b/0.2.0/genindex.html
new file mode 100644
index 0000000..a25ab61
--- /dev/null
+++ b/0.2.0/genindex.html
@@ -0,0 +1,1192 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>Index — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'genindex';</script>
+ <link rel="index" title="Index" href="#" />
+ <link rel="search" title="Search" href="search.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="index.html">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+ <div class="navbar-header-items__end">
+
+ <div class="navbar-item navbar-persistent--container">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+
+</div>
+
+ </nav>
+
+ <div class="bd-container">
+ <div class="bd-container__inner bd-page-width">
+
+ <div class="bd-sidebar-primary bd-sidebar">
+
+
+
+ <div class="sidebar-header-items sidebar-primary__section">
+
+
+ <div class="sidebar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+ <div class="sidebar-primary-items__start sidebar-primary__section">
+ <div class="sidebar-primary-item">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+
+ <div class="sidebar-primary-items__end sidebar-primary__section">
+ </div>
+
+ <div id="rtd-footer-container"></div>
+
+
+ </div>
+
+ <main id="main-content" class="bd-main">
+
+
+ <div class="bd-content">
+ <div class="bd-article-container">
+
+ <div class="bd-header-article"></div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article" role="main">
+
+
+<h1 id="index">Index</h1>
+
+<div class="genindex-jumpbox">
+ <a href="#_"><strong>_</strong></a>
+ | <a href="#A"><strong>A</strong></a>
+ | <a href="#I"><strong>I</strong></a>
+ | <a href="#M"><strong>M</strong></a>
+ | <a href="#N"><strong>N</strong></a>
+ | <a href="#R"><strong>R</strong></a>
+ | <a href="#U"><strong>U</strong></a>
+
+</div>
+<h2 id="_">_</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#c._NANOARROW_THROW_NOT_OK_IMPL">_NANOARROW_THROW_NOT_OK_IMPL (C macro)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="A">A</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="c.html#c.ARROW_C_DATA_INTERFACE">ARROW_C_DATA_INTERFACE (C macro)</a>
+</li>
+ <li><a href="c.html#c.ARROW_C_STREAM_INTERFACE">ARROW_C_STREAM_INTERFACE (C macro)</a>
+</li>
+ <li><a href="c.html#c.ARROW_FLAG_DICTIONARY_ORDERED">ARROW_FLAG_DICTIONARY_ORDERED (C macro)</a>
+</li>
+ <li><a href="c.html#c.ARROW_FLAG_MAP_KEYS_SORTED">ARROW_FLAG_MAP_KEYS_SORTED (C macro)</a>
+</li>
+ <li><a href="c.html#c.ARROW_FLAG_NULLABLE">ARROW_FLAG_NULLABLE (C macro)</a>
+</li>
+ <li><a href="c.html#_CPPv410ArrowArray">ArrowArray (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray7buffersE">ArrowArray::buffers (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray8childrenE">ArrowArray::children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray10dictionaryE">ArrowArray::dictionary (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray6lengthE">ArrowArray::length (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray9n_buffersE">ArrowArray::n_buffers (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray10n_childrenE">ArrowArray::n_children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray10null_countE">ArrowArray::null_count (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray6offsetE">ArrowArray::offset (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray12private_dataE">ArrowArray::private_data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowArray7releaseE">ArrowArray::release (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowArrayAllocateChildrenP10ArrowArray7int64_t">ArrowArrayAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv428ArrowArrayAllocateDictionaryP10ArrowArray">ArrowArrayAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowArrayAppendBytesP10ArrowArray15ArrowBufferView">ArrowArrayAppendBytes (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowArrayAppendDecimalP10ArrowArrayP12ArrowDecimal">ArrowArrayAppendDecimal (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowArrayAppendDoubleP10ArrowArrayd">ArrowArrayAppendDouble (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowArrayAppendEmptyP10ArrowArray7int64_t">ArrowArrayAppendEmpty (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowArrayAppendIntP10ArrowArray7int64_t">ArrowArrayAppendInt (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowArrayAppendNullP10ArrowArray7int64_t">ArrowArrayAppendNull (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowArrayAppendStringP10ArrowArray15ArrowStringView">ArrowArrayAppendString (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowArrayAppendUIntP10ArrowArray8uint64_t">ArrowArrayAppendUInt (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowArrayBufferP10ArrowArray7int64_t">ArrowArrayBuffer (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowArrayFinishBuildingP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowArrayFinishBuilding (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv431ArrowArrayFinishBuildingDefaultP10ArrowArrayP10ArrowError">ArrowArrayFinishBuildingDefault (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowArrayFinishElementP10ArrowArray">ArrowArrayFinishElement (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv428ArrowArrayFinishUnionElementP10ArrowArray6int8_t">ArrowArrayFinishUnionElement (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowArrayInitFromArrayViewP10ArrowArrayP14ArrowArrayViewP10ArrowError">ArrowArrayInitFromArrayView (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowArrayInitFromSchemaP10ArrowArrayP11ArrowSchemaP10ArrowError">ArrowArrayInitFromSchema (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowArrayInitFromTypeP10ArrowArray9ArrowType">ArrowArrayInitFromType (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv414ArrowArrayMoveP10ArrowArrayP10ArrowArray">ArrowArrayMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowArrayReserveP10ArrowArray7int64_t">ArrowArrayReserve (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowArraySetBufferP10ArrowArray7int64_tP11ArrowBuffer">ArrowArraySetBuffer (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowArraySetValidityBitmapP10ArrowArrayP11ArrowBitmap">ArrowArraySetValidityBitmap (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowArrayShrinkToFitP10ArrowArray">ArrowArrayShrinkToFit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowArrayStartAppendingP10ArrowArray">ArrowArrayStartAppending (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowArrayStream">ArrowArrayStream (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N16ArrowArrayStream14get_last_errorE">ArrowArrayStream::get_last_error (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N16ArrowArrayStream8get_nextE">ArrowArrayStream::get_next (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N16ArrowArrayStream10get_schemaE">ArrowArrayStream::get_schema (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N16ArrowArrayStream12private_dataE">ArrowArrayStream::private_data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N16ArrowArrayStream7releaseE">ArrowArrayStream::release (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowArrayStreamMoveP16ArrowArrayStreamP16ArrowArrayStream">ArrowArrayStreamMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowArrayValidityBitmapP10ArrowArray">ArrowArrayValidityBitmap (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv414ArrowArrayView">ArrowArrayView (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView5arrayE">ArrowArrayView::array (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView12buffer_viewsE">ArrowArrayView::buffer_views (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView8childrenE">ArrowArrayView::children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView10dictionaryE">ArrowArrayView::dictionary (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView6layoutE">ArrowArrayView::layout (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView6lengthE">ArrowArrayView::length (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView10n_childrenE">ArrowArrayView::n_children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView10null_countE">ArrowArrayView::null_count (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView6offsetE">ArrowArrayView::offset (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView12storage_typeE">ArrowArrayView::storage_type (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N14ArrowArrayView17union_type_id_mapE">ArrowArrayView::union_type_id_map (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv430ArrowArrayViewAllocateChildrenP14ArrowArrayView7int64_t">ArrowArrayViewAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv432ArrowArrayViewAllocateDictionaryP14ArrowArrayView">ArrowArrayViewAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv428ArrowArrayViewGetBytesUnsafeP14ArrowArrayView7int64_t">ArrowArrayViewGetBytesUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv430ArrowArrayViewGetDecimalUnsafeP14ArrowArrayView7int64_tP12ArrowDecimal">ArrowArrayViewGetDecimalUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv429ArrowArrayViewGetDoubleUnsafeP14ArrowArrayView7int64_t">ArrowArrayViewGetDoubleUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowArrayViewGetIntUnsafeP14ArrowArrayView7int64_t">ArrowArrayViewGetIntUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv429ArrowArrayViewGetStringUnsafeP14ArrowArrayView7int64_t">ArrowArrayViewGetStringUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowArrayViewGetUIntUnsafeP14ArrowArrayView7int64_t">ArrowArrayViewGetUIntUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv428ArrowArrayViewInitFromSchemaP14ArrowArrayViewP11ArrowSchemaP10ArrowError">ArrowArrayViewInitFromSchema (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowArrayViewInitFromTypeP14ArrowArrayView9ArrowType">ArrowArrayViewInitFromType (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowArrayViewIsNullP14ArrowArrayView7int64_t">ArrowArrayViewIsNull (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowArrayViewMoveP14ArrowArrayViewP14ArrowArrayView">ArrowArrayViewMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowArrayViewResetP14ArrowArrayView">ArrowArrayViewReset (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowArrayViewSetArrayP14ArrowArrayViewP10ArrowArrayP10ArrowError">ArrowArrayViewSetArray (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowArrayViewSetLengthP14ArrowArrayView7int64_t">ArrowArrayViewSetLength (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv429ArrowArrayViewUnionChildIndexP14ArrowArrayView7int64_t">ArrowArrayViewUnionChildIndex (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv430ArrowArrayViewUnionChildOffsetP14ArrowArrayView7int64_t">ArrowArrayViewUnionChildOffset (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv425ArrowArrayViewUnionTypeIdP14ArrowArrayView7int64_t">ArrowArrayViewUnionTypeId (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowArrayViewValidateP14ArrowArrayView20ArrowValidationLevelP10ArrowError">ArrowArrayViewValidate (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv413ArrowBitClearP7uint8_t7int64_t">ArrowBitClear (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowBitCountSetPK7uint8_t7int64_t7int64_t">ArrowBitCountSet (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowBitGetPK7uint8_t7int64_t">ArrowBitGet (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowBitmap">ArrowBitmap (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBitmap6bufferE">ArrowBitmap::buffer (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBitmap9size_bitsE">ArrowBitmap::size_bits (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowBitmapAppendP11ArrowBitmap7uint8_t7int64_t">ArrowBitmapAppend (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv428ArrowBitmapAppendInt32UnsafeP11ArrowBitmapPK7int32_t7int64_t">ArrowBitmapAppendInt32Unsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowBitmapAppendInt8UnsafeP11ArrowBitmapPK6int8_t7int64_t">ArrowBitmapAppendInt8Unsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBitmapAppendUnsafeP11ArrowBitmap7uint8_t7int64_t">ArrowBitmapAppendUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBitmapInitP11ArrowBitmap">ArrowBitmapInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBitmapMoveP11ArrowBitmapP11ArrowBitmap">ArrowBitmapMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowBitmapReserveP11ArrowBitmap7int64_t">ArrowBitmapReserve (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowBitmapResetP11ArrowBitmap">ArrowBitmapReset (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowBitmapResizeP11ArrowBitmap7int64_tc">ArrowBitmapResize (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowBitSetP7uint8_t7int64_t">ArrowBitSet (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv413ArrowBitSetToP7uint8_t7int64_t7uint8_t">ArrowBitSetTo (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv414ArrowBitsSetToP7uint8_t7int64_t7int64_t7uint8_t">ArrowBitsSetTo (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowBuffer">ArrowBuffer (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBuffer9allocatorE">ArrowBuffer::allocator (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBuffer14capacity_bytesE">ArrowBuffer::capacity_bytes (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBuffer4dataE">ArrowBuffer::data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowBuffer10size_bytesE">ArrowBuffer::size_bytes (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowBufferAllocator">ArrowBufferAllocator (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowBufferAllocator4freeE">ArrowBufferAllocator::free (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowBufferAllocator12private_dataE">ArrowBufferAllocator::private_data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowBufferAllocator10reallocateE">ArrowBufferAllocator::reallocate (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowBufferAllocatorDefaultv">ArrowBufferAllocatorDefault (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowBufferAppendP11ArrowBufferPKv7int64_t">ArrowBufferAppend (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowBufferAppendBufferViewP11ArrowBuffer15ArrowBufferView">ArrowBufferAppendBufferView (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferAppendDoubleP11ArrowBufferd">ArrowBufferAppendDouble (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowBufferAppendFillP11ArrowBuffer7uint8_t7int64_t">ArrowBufferAppendFill (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferAppendFloatP11ArrowBufferf">ArrowBufferAppendFloat (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferAppendInt16P11ArrowBuffer7int16_t">ArrowBufferAppendInt16 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferAppendInt32P11ArrowBuffer7int32_t">ArrowBufferAppendInt32 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferAppendInt64P11ArrowBuffer7int64_t">ArrowBufferAppendInt64 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowBufferAppendInt8P11ArrowBuffer6int8_t">ArrowBufferAppendInt8 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowBufferAppendStringViewP11ArrowBuffer15ArrowStringView">ArrowBufferAppendStringView (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferAppendUInt16P11ArrowBuffer8uint16_t">ArrowBufferAppendUInt16 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferAppendUInt32P11ArrowBuffer8uint32_t">ArrowBufferAppendUInt32 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferAppendUInt64P11ArrowBuffer8uint64_t">ArrowBufferAppendUInt64 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferAppendUInt8P11ArrowBuffer7uint8_t">ArrowBufferAppendUInt8 (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t">ArrowBufferAppendUnsafe (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv">ArrowBufferDeallocator (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBufferInitP11ArrowBuffer">ArrowBufferInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBufferMoveP11ArrowBufferP11ArrowBuffer">ArrowBufferMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowBufferReserveP11ArrowBuffer7int64_t">ArrowBufferReserve (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowBufferResetP11ArrowBuffer">ArrowBufferReset (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowBufferResizeP11ArrowBuffer7int64_tc">ArrowBufferResize (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowBufferSetAllocatorP11ArrowBuffer20ArrowBufferAllocator">ArrowBufferSetAllocator (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBufferType">ArrowBufferType (C++ enum)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_DATAE">ArrowBufferType::NANOARROW_BUFFER_TYPE_DATA (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType33NANOARROW_BUFFER_TYPE_DATA_OFFSETE">ArrowBufferType::NANOARROW_BUFFER_TYPE_DATA_OFFSET (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_NONEE">ArrowBufferType::NANOARROW_BUFFER_TYPE_NONE (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType29NANOARROW_BUFFER_TYPE_TYPE_IDE">ArrowBufferType::NANOARROW_BUFFER_TYPE_TYPE_ID (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType34NANOARROW_BUFFER_TYPE_UNION_OFFSETE">ArrowBufferType::NANOARROW_BUFFER_TYPE_UNION_OFFSET (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferType30NANOARROW_BUFFER_TYPE_VALIDITYE">ArrowBufferType::NANOARROW_BUFFER_TYPE_VALIDITY (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowBufferView">ArrowBufferView (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferView4dataE">ArrowBufferView::data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowBufferView10size_bytesE">ArrowBufferView::size_bytes (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv413ArrowCharViewPKc">ArrowCharView (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv412ArrowDecimal">ArrowDecimal (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal15high_word_indexE">ArrowDecimal::high_word_index (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal14low_word_indexE">ArrowDecimal::low_word_index (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal7n_wordsE">ArrowDecimal::n_words (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal9precisionE">ArrowDecimal::precision (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal5scaleE">ArrowDecimal::scale (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N12ArrowDecimal5wordsE">ArrowDecimal::words (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowDecimalGetBytesP12ArrowDecimalP7uint8_t">ArrowDecimalGetBytes (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowDecimalInitP12ArrowDecimal7int32_t7int32_t7int32_t">ArrowDecimalInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowDecimalSetBytesP12ArrowDecimalPK7uint8_t">ArrowDecimalSetBytes (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowDecimalSetIntP12ArrowDecimal7int64_t">ArrowDecimalSetInt (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv416ArrowDecimalSignP12ArrowDecimal">ArrowDecimalSign (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv410ArrowError">ArrowError (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N10ArrowError7messageE">ArrowError::message (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv414ArrowErrorCode">ArrowErrorCode (C++ type)</a>
+</li>
+ <li><a href="c.html#_CPPv414ArrowErrorInitP10ArrowError">ArrowErrorInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv417ArrowErrorMessageP10ArrowError">ArrowErrorMessage (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv413ArrowErrorSetP10ArrowErrorPKcz">ArrowErrorSet (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv49ArrowFreePv">ArrowFree (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv429ArrowIpcArrayStreamReaderInitP16ArrowArrayStreamP19ArrowIpcInputStreamP32ArrowIpcArrayStreamReaderOptions">ArrowIpcArrayStreamReaderInit (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv432ArrowIpcArrayStreamReaderOptions">ArrowIpcArrayStreamReaderOptions (C++ struct)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N32ArrowIpcArrayStreamReaderOptions11field_indexE">ArrowIpcArrayStreamReaderOptions::field_index (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N32ArrowIpcArrayStreamReaderOptions18use_shared_buffersE">ArrowIpcArrayStreamReaderOptions::use_shared_buffers (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv420ArrowIpcCheckRuntimeP10ArrowError">ArrowIpcCheckRuntime (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv423ArrowIpcCompressionType">ArrowIpcCompressionType (C++ enum)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcCompressionType40NANOARROW_IPC_COMPRESSION_TYPE_LZ4_FRAMEE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_LZ4_FRAME (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcCompressionType35NANOARROW_IPC_COMPRESSION_TYPE_NONEE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_NONE (C++ enumerator)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcCompressionType35NANOARROW_IPC_COMPRESSION_TYPE_ZSTDE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_ZSTD (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv415ArrowIpcDecoder">ArrowIpcDecoder (C++ struct)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder15body_size_bytesE">ArrowIpcDecoder::body_size_bytes (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder5codecE">ArrowIpcDecoder::codec (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder10endiannessE">ArrowIpcDecoder::endianness (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder13feature_flagsE">ArrowIpcDecoder::feature_flags (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder17header_size_bytesE">ArrowIpcDecoder::header_size_bytes (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder12message_typeE">ArrowIpcDecoder::message_type (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder16metadata_versionE">ArrowIpcDecoder::metadata_version (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N15ArrowIpcDecoder12private_dataE">ArrowIpcDecoder::private_data (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv426ArrowIpcDecoderDecodeArrayP15ArrowIpcDecoder15ArrowBufferView7int64_tP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowIpcDecoderDecodeArray (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv436ArrowIpcDecoderDecodeArrayFromSharedP15ArrowIpcDecoderP20ArrowIpcSharedBuffer7int64_tP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowIpcDecoderDecodeArrayFromShared (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv430ArrowIpcDecoderDecodeArrayViewP15ArrowIpcDecoder15ArrowBufferView7int64_tPP14ArrowArrayViewP10ArrowError">ArrowIpcDecoderDecodeArrayView (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv427ArrowIpcDecoderDecodeHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderDecodeHeader (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv427ArrowIpcDecoderDecodeSchemaP15ArrowIpcDecoderP11ArrowSchemaP10ArrowError">ArrowIpcDecoderDecodeSchema (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv419ArrowIpcDecoderInitP15ArrowIpcDecoder">ArrowIpcDecoderInit (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv425ArrowIpcDecoderPeekHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderPeekHeader (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv420ArrowIpcDecoderResetP15ArrowIpcDecoder">ArrowIpcDecoderReset (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv428ArrowIpcDecoderSetEndiannessP15ArrowIpcDecoder18ArrowIpcEndianness">ArrowIpcDecoderSetEndianness (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv424ArrowIpcDecoderSetSchemaP15ArrowIpcDecoderP11ArrowSchemaP10ArrowError">ArrowIpcDecoderSetSchema (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv427ArrowIpcDecoderVerifyHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderVerifyHeader (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv418ArrowIpcEndianness">ArrowIpcEndianness (C++ enum)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N18ArrowIpcEndianness28NANOARROW_IPC_ENDIANNESS_BIGE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_BIG (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N18ArrowIpcEndianness31NANOARROW_IPC_ENDIANNESS_LITTLEE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_LITTLE (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N18ArrowIpcEndianness38NANOARROW_IPC_ENDIANNESS_UNINITIALIZEDE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv419ArrowIpcInputStream">ArrowIpcInputStream (C++ struct)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcInputStream12private_dataE">ArrowIpcInputStream::private_data (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcInputStream4readE">ArrowIpcInputStream::read (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcInputStream7releaseE">ArrowIpcInputStream::release (C++ member)</a>
+</li>
+ <li><a href="ipc.html#_CPPv429ArrowIpcInputStreamInitBufferP19ArrowIpcInputStreamP11ArrowBuffer">ArrowIpcInputStreamInitBuffer (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv427ArrowIpcInputStreamInitFileP19ArrowIpcInputStreamPvi">ArrowIpcInputStreamInitFile (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv423ArrowIpcInputStreamMoveP19ArrowIpcInputStreamP19ArrowIpcInputStream">ArrowIpcInputStreamMove (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv419ArrowIpcMessageType">ArrowIpcMessageType (C++ enum)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType43NANOARROW_IPC_MESSAGE_TYPE_DICTIONARY_BATCHE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_DICTIONARY_BATCH (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType39NANOARROW_IPC_MESSAGE_TYPE_RECORD_BATCHE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_RECORD_BATCH (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType33NANOARROW_IPC_MESSAGE_TYPE_SCHEMAE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_SCHEMA (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType40NANOARROW_IPC_MESSAGE_TYPE_SPARSE_TENSORE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_SPARSE_TENSOR (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType33NANOARROW_IPC_MESSAGE_TYPE_TENSORE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_TENSOR (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N19ArrowIpcMessageType40NANOARROW_IPC_MESSAGE_TYPE_UNINITIALIZEDE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv423ArrowIpcMetadataVersion">ArrowIpcMetadataVersion (C++ enum)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V1E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V1 (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V2E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V2 (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V3E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V3 (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V4E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V4 (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V5E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V5 (C++ enumerator)</a>
+</li>
+ <li><a href="ipc.html#_CPPv420ArrowIpcSharedBuffer">ArrowIpcSharedBuffer (C++ struct)</a>
+</li>
+ <li><a href="ipc.html#_CPPv424ArrowIpcSharedBufferInitP20ArrowIpcSharedBufferP11ArrowBuffer">ArrowIpcSharedBufferInit (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv432ArrowIpcSharedBufferIsThreadSafev">ArrowIpcSharedBufferIsThreadSafe (C++ function)</a>
+</li>
+ <li><a href="ipc.html#_CPPv425ArrowIpcSharedBufferResetP20ArrowIpcSharedBuffer">ArrowIpcSharedBufferReset (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowLayout">ArrowLayout (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowLayout16buffer_data_typeE">ArrowLayout::buffer_data_type (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowLayout11buffer_typeE">ArrowLayout::buffer_type (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowLayout19child_size_elementsE">ArrowLayout::child_size_elements (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowLayout17element_size_bitsE">ArrowLayout::element_size_bits (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowLayoutInitP11ArrowLayout9ArrowType">ArrowLayoutInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowMalloc7int64_t">ArrowMalloc (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowMetadataBuilderAppendP11ArrowBuffer15ArrowStringView15ArrowStringView">ArrowMetadataBuilderAppend (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowMetadataBuilderInitP11ArrowBufferPKc">ArrowMetadataBuilderInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowMetadataBuilderRemoveP11ArrowBuffer15ArrowStringView">ArrowMetadataBuilderRemove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowMetadataBuilderSetP11ArrowBuffer15ArrowStringView15ArrowStringView">ArrowMetadataBuilderSet (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowMetadataGetValuePKc15ArrowStringViewP15ArrowStringView">ArrowMetadataGetValue (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowMetadataHasKeyPKc15ArrowStringView">ArrowMetadataHasKey (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowMetadataReader">ArrowMetadataReader (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N19ArrowMetadataReader8metadataE">ArrowMetadataReader::metadata (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N19ArrowMetadataReader6offsetE">ArrowMetadataReader::offset (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N19ArrowMetadataReader14remaining_keysE">ArrowMetadataReader::remaining_keys (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowMetadataReaderInitP19ArrowMetadataReaderPKc">ArrowMetadataReaderInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowMetadataReaderReadP19ArrowMetadataReaderP15ArrowStringViewP15ArrowStringView">ArrowMetadataReaderRead (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowMetadataSizeOfPKc">ArrowMetadataSizeOf (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv421ArrowNanoarrowVersionv">ArrowNanoarrowVersion (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowNanoarrowVersionIntv">ArrowNanoarrowVersionInt (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv412ArrowReallocPv7int64_t">ArrowRealloc (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv411ArrowSchema">ArrowSchema (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema8childrenE">ArrowSchema::children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema10dictionaryE">ArrowSchema::dictionary (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema5flagsE">ArrowSchema::flags (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema6formatE">ArrowSchema::format (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema8metadataE">ArrowSchema::metadata (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema10n_childrenE">ArrowSchema::n_children (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema4nameE">ArrowSchema::name (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema12private_dataE">ArrowSchema::private_data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N11ArrowSchema7releaseE">ArrowSchema::release (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowSchemaAllocateChildrenP11ArrowSchema7int64_t">ArrowSchemaAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv429ArrowSchemaAllocateDictionaryP11ArrowSchema">ArrowSchemaAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowSchemaDeepCopyP11ArrowSchemaP11ArrowSchema">ArrowSchemaDeepCopy (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowSchemaInitP11ArrowSchema">ArrowSchemaInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowSchemaInitFromTypeP11ArrowSchema9ArrowType">ArrowSchemaInitFromType (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowSchemaMoveP11ArrowSchemaP11ArrowSchema">ArrowSchemaMove (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowSchemaSetFormatP11ArrowSchemaPKc">ArrowSchemaSetFormat (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv422ArrowSchemaSetMetadataP11ArrowSchemaPKc">ArrowSchemaSetMetadata (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowSchemaSetNameP11ArrowSchemaPKc">ArrowSchemaSetName (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv418ArrowSchemaSetTypeP11ArrowSchema9ArrowType">ArrowSchemaSetType (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv426ArrowSchemaSetTypeDateTimeP11ArrowSchema9ArrowType13ArrowTimeUnitPKc">ArrowSchemaSetTypeDateTime (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv425ArrowSchemaSetTypeDecimalP11ArrowSchema9ArrowType7int32_t7int32_t">ArrowSchemaSetTypeDecimal (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv427ArrowSchemaSetTypeFixedSizeP11ArrowSchema9ArrowType7int32_t">ArrowSchemaSetTypeFixedSize (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv424ArrowSchemaSetTypeStructP11ArrowSchema7int64_t">ArrowSchemaSetTypeStruct (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv423ArrowSchemaSetTypeUnionP11ArrowSchema9ArrowType7int64_t">ArrowSchemaSetTypeUnion (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowSchemaToStringP11ArrowSchemaPc7int64_tc">ArrowSchemaToString (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowSchemaView">ArrowSchemaView (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView16decimal_bitwidthE">ArrowSchemaView::decimal_bitwidth (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView17decimal_precisionE">ArrowSchemaView::decimal_precision (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView13decimal_scaleE">ArrowSchemaView::decimal_scale (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView18extension_metadataE">ArrowSchemaView::extension_metadata (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView14extension_nameE">ArrowSchemaView::extension_name (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView10fixed_sizeE">ArrowSchemaView::fixed_size (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView6layoutE">ArrowSchemaView::layout (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView6schemaE">ArrowSchemaView::schema (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView12storage_typeE">ArrowSchemaView::storage_type (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView9time_unitE">ArrowSchemaView::time_unit (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView8timezoneE">ArrowSchemaView::timezone (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView4typeE">ArrowSchemaView::type (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowSchemaView14union_type_idsE">ArrowSchemaView::union_type_ids (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowSchemaViewInitP15ArrowSchemaViewP11ArrowSchemaP10ArrowError">ArrowSchemaViewInit (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowStringView">ArrowStringView (C++ struct)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowStringView4dataE">ArrowStringView::data (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv4N15ArrowStringView10size_bytesE">ArrowStringView::size_bytes (C++ member)</a>
+</li>
+ <li><a href="c.html#_CPPv413ArrowTimeUnit">ArrowTimeUnit (C++ enum)</a>
+</li>
+ <li><a href="c.html#_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MICROE">ArrowTimeUnit::NANOARROW_TIME_UNIT_MICRO (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MILLIE">ArrowTimeUnit::NANOARROW_TIME_UNIT_MILLI (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N13ArrowTimeUnit24NANOARROW_TIME_UNIT_NANOE">ArrowTimeUnit::NANOARROW_TIME_UNIT_NANO (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N13ArrowTimeUnit26NANOARROW_TIME_UNIT_SECONDE">ArrowTimeUnit::NANOARROW_TIME_UNIT_SECOND (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv419ArrowTimeUnitString13ArrowTimeUnit">ArrowTimeUnitString (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv49ArrowType">ArrowType (C++ enum)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_BINARYE">ArrowType::NANOARROW_TYPE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_BOOLE">ArrowType::NANOARROW_TYPE_BOOL (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DATE32E">ArrowType::NANOARROW_TYPE_DATE32 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DATE64E">ArrowType::NANOARROW_TYPE_DATE64 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL128E">ArrowType::NANOARROW_TYPE_DECIMAL128 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL256E">ArrowType::NANOARROW_TYPE_DECIMAL256 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType26NANOARROW_TYPE_DENSE_UNIONE">ArrowType::NANOARROW_TYPE_DENSE_UNION (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DICTIONARYE">ArrowType::NANOARROW_TYPE_DICTIONARY (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DOUBLEE">ArrowType::NANOARROW_TYPE_DOUBLE (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType23NANOARROW_TYPE_DURATIONE">ArrowType::NANOARROW_TYPE_DURATION (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType24NANOARROW_TYPE_EXTENSIONE">ArrowType::NANOARROW_TYPE_EXTENSION (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType32NANOARROW_TYPE_FIXED_SIZE_BINARYE">ArrowType::NANOARROW_TYPE_FIXED_SIZE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType30NANOARROW_TYPE_FIXED_SIZE_LISTE">ArrowType::NANOARROW_TYPE_FIXED_SIZE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_FLOATE">ArrowType::NANOARROW_TYPE_FLOAT (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_HALF_FLOATE">ArrowType::NANOARROW_TYPE_HALF_FLOAT (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT16E">ArrowType::NANOARROW_TYPE_INT16 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT32E">ArrowType::NANOARROW_TYPE_INT32 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT64E">ArrowType::NANOARROW_TYPE_INT64 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_INT8E">ArrowType::NANOARROW_TYPE_INT8 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType32NANOARROW_TYPE_INTERVAL_DAY_TIMEE">ArrowType::NANOARROW_TYPE_INTERVAL_DAY_TIME (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType38NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANOE">ArrowType::NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType30NANOARROW_TYPE_INTERVAL_MONTHSE">ArrowType::NANOARROW_TYPE_INTERVAL_MONTHS (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_BINARYE">ArrowType::NANOARROW_TYPE_LARGE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_LARGE_LISTE">ArrowType::NANOARROW_TYPE_LARGE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_STRINGE">ArrowType::NANOARROW_TYPE_LARGE_STRING (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_LISTE">ArrowType::NANOARROW_TYPE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType18NANOARROW_TYPE_MAPE">ArrowType::NANOARROW_TYPE_MAP (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType17NANOARROW_TYPE_NAE">ArrowType::NANOARROW_TYPE_NA (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_SPARSE_UNIONE">ArrowType::NANOARROW_TYPE_SPARSE_UNION (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_STRINGE">ArrowType::NANOARROW_TYPE_STRING (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_STRUCTE">ArrowType::NANOARROW_TYPE_STRUCT (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_TIME32E">ArrowType::NANOARROW_TYPE_TIME32 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_TIME64E">ArrowType::NANOARROW_TYPE_TIME64 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType24NANOARROW_TYPE_TIMESTAMPE">ArrowType::NANOARROW_TYPE_TIMESTAMP (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT16E">ArrowType::NANOARROW_TYPE_UINT16 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT32E">ArrowType::NANOARROW_TYPE_UINT32 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT64E">ArrowType::NANOARROW_TYPE_UINT64 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_UINT8E">ArrowType::NANOARROW_TYPE_UINT8 (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N9ArrowType28NANOARROW_TYPE_UNINITIALIZEDE">ArrowType::NANOARROW_TYPE_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv415ArrowTypeString9ArrowType">ArrowTypeString (C++ function)</a>
+</li>
+ <li><a href="c.html#_CPPv420ArrowValidationLevel">ArrowValidationLevel (C++ enum)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_DEFAULTE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_DEFAULT (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_FULLE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_FULL (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_MINIMALE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_MINIMAL (C++ enumerator)</a>
+</li>
+ <li><a href="c.html#_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_NONEE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_NONE (C++ enumerator)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="I">I</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv412init_pointerP10ArrowArray">init_pointer (C++ function)</a>, <a href="cpp.html#_CPPv412init_pointerP11ArrowBitmap">[1]</a>, <a href="cpp.html#_CPPv412init_pointerP11ArrowBuffer">[2]</a>, <a href="cpp.html#_CPPv412init_pointerP11ArrowSchema">[3]</a>, <a href="cpp.html#_CPPv412init_pointerP14ArrowArrayView">[4]</a>, <a href="cpp.html#_CPPv412init_pointerP16ArrowArrayStream">[5]</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="M">M</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv412move_pointerP10ArrowArrayP10ArrowArray">move_pointer (C++ function)</a>, <a href="cpp.html#_CPPv412move_pointerP11ArrowBitmapP11ArrowBitmap">[1]</a>, <a href="cpp.html#_CPPv412move_pointerP11ArrowBufferP11ArrowBuffer">[2]</a>, <a href="cpp.html#_CPPv412move_pointerP11ArrowSchemaP11ArrowSchema">[3]</a>, <a href="cpp.html#_CPPv412move_pointerP14ArrowArrayViewP14ArrowArrayView">[4]</a>, <a href="cpp.html#_CPPv412move_pointerP16ArrowArrayStreamP16ArrowArra [...]
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="N">N</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow16EmptyArrayStreamE">nanoarrow::EmptyArrayStream (C++ class)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow16EmptyArrayStream10MakeUniqueEP11ArrowSchema">nanoarrow::EmptyArrayStream::MakeUnique (C++ function)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow9ExceptionE">nanoarrow::Exception (C++ class)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4I0EN9nanoarrow8internal6UniqueE">nanoarrow::internal::Unique (C++ class)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique3getEv">nanoarrow::internal::Unique::get (C++ function)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique4moveEP1T">nanoarrow::internal::Unique::move (C++ function)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow8internal6UniqueptEv">nanoarrow::internal::Unique::operator-> (C++ function)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique5resetEP1T">nanoarrow::internal::Unique::reset (C++ function)</a>, <a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique5resetEv">[1]</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueEP1T">nanoarrow::internal::Unique::Unique (C++ function)</a>, <a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueERR6Unique">[1]</a>, <a href="cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueEv">[2]</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow17VectorArrayStreamE">nanoarrow::VectorArrayStream (C++ class)</a>
+</li>
+ <li><a href="cpp.html#_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaNSt6vectorI11UniqueArrayEE">nanoarrow::VectorArrayStream::MakeUnique (C++ function)</a>, <a href="cpp.html#_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaP10ArrowArray">[1]</a>
+</li>
+ <li><a href="ipc.html#c.NANOARROW_IPC_FEATURE_COMPRESSED_BODY">NANOARROW_IPC_FEATURE_COMPRESSED_BODY (C macro)</a>
+</li>
+ <li><a href="ipc.html#c.NANOARROW_IPC_FEATURE_DICTIONARY_REPLACEMENT">NANOARROW_IPC_FEATURE_DICTIONARY_REPLACEMENT (C macro)</a>
+</li>
+ <li><a href="c.html#c.NANOARROW_OK">NANOARROW_OK (C macro)</a>
+</li>
+ <li><a href="c.html#c.NANOARROW_RETURN_NOT_OK">NANOARROW_RETURN_NOT_OK (C macro)</a>
+</li>
+ <li><a href="c.html#c.NANOARROW_RETURN_NOT_OK_WITH_ERROR">NANOARROW_RETURN_NOT_OK_WITH_ERROR (C macro)</a>
+</li>
+ <li><a href="cpp.html#c.NANOARROW_THROW_NOT_OK">NANOARROW_THROW_NOT_OK (C macro)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="R">R</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv415release_pointerP10ArrowArray">release_pointer (C++ function)</a>, <a href="cpp.html#_CPPv415release_pointerP11ArrowBitmap">[1]</a>, <a href="cpp.html#_CPPv415release_pointerP11ArrowBuffer">[2]</a>, <a href="cpp.html#_CPPv415release_pointerP11ArrowSchema">[3]</a>, <a href="cpp.html#_CPPv415release_pointerP14ArrowArrayView">[4]</a>, <a href="cpp.html#_CPPv415release_pointerP16ArrowArrayStream">[5]</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="U">U</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv411UniqueArray">UniqueArray (C++ type)</a>
+</li>
+ <li><a href="cpp.html#_CPPv417UniqueArrayStream">UniqueArrayStream (C++ type)</a>
+</li>
+ <li><a href="cpp.html#_CPPv415UniqueArrayView">UniqueArrayView (C++ type)</a>
+</li>
+ <li><a href="cpp.html#_CPPv412UniqueBitmap">UniqueBitmap (C++ type)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="cpp.html#_CPPv412UniqueBuffer">UniqueBuffer (C++ type)</a>
+</li>
+ <li><a href="ipc.html#_CPPv413UniqueDecoder">UniqueDecoder (C++ type)</a>
+</li>
+ <li><a href="ipc.html#_CPPv417UniqueInputStream">UniqueInputStream (C++ type)</a>
+</li>
+ <li><a href="cpp.html#_CPPv412UniqueSchema">UniqueSchema (C++ type)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+
+
+ </article>
+
+
+
+ <footer class="bd-footer-article">
+
+<div class="footer-article-items footer-article__inner">
+
+ <div class="footer-article-item"><!-- Previous / next buttons -->
+<div class="prev-next-area">
+</div></div>
+
+</div>
+
+ </footer>
+
+ </div>
+
+
+
+
+ </div>
+ <footer class="bd-footer-content">
+
+ </footer>
+
+ </main>
+ </div>
+ </div>
+
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="_static/scripts/bootstrap.js?digest=e353d410970836974a52"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52"></script>
+
+ <footer class="bd-footer">
+<div class="bd-footer__inner bd-page-width">
+
+ <div class="footer-items__start">
+
+ <div class="footer-item">
+ <p class="copyright">
+
+ © Copyright 2016-2023 Apache Software Foundation.
+ <br/>
+
+ </p>
+</div>
+
+ <div class="footer-item">
+ <p class="sphinx-version">
+ Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.0.1.
+ <br/>
+ </p>
+</div>
+
+ </div>
+
+
+ <div class="footer-items__end">
+
+ <div class="footer-item"><p class="theme-version">
+ Built with the <a href="https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html">PyData Sphinx Theme</a> 0.13.3.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/0.2.0/getting-started.html b/0.2.0/getting-started.html
new file mode 100644
index 0000000..49b90cf
--- /dev/null
+++ b/0.2.0/getting-started.html
@@ -0,0 +1,998 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+
+ <title>Getting started with nanoarrow — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started';</script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="C API Reference" href="c.html" />
+ <link rel="prev" title="nanoarrow" href="index.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="index.html">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+ <div class="navbar-header-items__end">
+
+ <div class="navbar-item navbar-persistent--container">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </nav>
+
+ <div class="bd-container">
+ <div class="bd-container__inner bd-page-width">
+
+ <div class="bd-sidebar-primary bd-sidebar">
+
+
+
+ <div class="sidebar-header-items sidebar-primary__section">
+
+
+ <div class="sidebar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="#">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+ <div class="sidebar-primary-items__start sidebar-primary__section">
+ <div class="sidebar-primary-item">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+
+ <div class="sidebar-primary-items__end sidebar-primary__section">
+ </div>
+
+ <div id="rtd-footer-container"></div>
+
+
+ </div>
+
+ <main id="main-content" class="bd-main">
+
+
+ <div class="bd-content">
+ <div class="bd-article-container">
+
+ <div class="bd-header-article">
+<div class="header-article-items header-article__inner">
+
+ <div class="header-article-items__start">
+
+ <div class="header-article-item">
+
+
+
+<nav aria-label="Breadcrumbs">
+ <ul class="bd-breadcrumbs" role="navigation" aria-label="Breadcrumb">
+
+ <li class="breadcrumb-item breadcrumb-home">
+ <a href="index.html" class="nav-link" aria-label="Home">
+ <i class="fa-solid fa-home"></i>
+ </a>
+ </li>
+ <li class="breadcrumb-item active" aria-current="page">Getting started with nanoarrow</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article" role="main">
+
+ <!---
+ 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.
+--><section id="getting-started-with-nanoarrow">
+<h1>Getting started with nanoarrow<a class="headerlink" href="#getting-started-with-nanoarrow" title="Permalink to this heading">#</a></h1>
+<p>This tutorial provides a short example of writing a C++ library that
+exposes an Arrow-based API and uses nanoarrow to implement a simple text
+file reader/writer. In general, nanoarrow can help you write a library
+or application that:</p>
+<ul class="simple">
+<li><p>exposes an Arrow-based API to read from a data source or format,</p></li>
+<li><p>exposes an Arrow-based API to write to a data source or format,</p></li>
+<li><p>exposes one or more compute functions that operates on and produces
+data in the form of Arrow arrays, and/or</p></li>
+<li><p>exposes an extension type implementation.</p></li>
+</ul>
+<p>Becauase Arrow has bindings in many languages, it means that you or
+others can easily bind or use your tool in higher-level runtimes like R,
+Java, C++, Python, Rust, Julia, Go, or Ruby, among others.</p>
+<p>The nanoarrow library is not the only way that an Arrow-based API can be
+implemented: Arrow C++, Rust, and Go are all excellent choices and can
+compile into static libraries that are C-linkable from other languages;
+however, existing Arrow implementations produce relatively large static
+libraries and can present complex build-time or run-time linking
+requirements depending on the implementation and features used. If the
+set of libraries you’re working with already provide the conveniences
+you require, nanoarrow may provide all the functionality you need.</p>
+<p>Now that we’ve talked about why you might want to build a library with
+nanoarrow…let’s build one!</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>This tutorial also goes over some of the basic structure of writing a C++ library.
+If you already know how to do this, feel free to scroll to the code examples provided
+below or take a look at the
+<a class="reference external" href="https://github.com/apache/arrow-nanoarrow/tree/main/examples/linesplitter">final example project</a>.</p>
+</div>
+<section id="the-library">
+<h2>The library<a class="headerlink" href="#the-library" title="Permalink to this heading">#</a></h2>
+<p>The library we’ll write in this tutorial is a simple text processing
+library that splits and reassembles lines of text. It will be able to:</p>
+<ul class="simple">
+<li><p>Read text from a buffer into an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> as one element per
+line, and</p></li>
+<li><p>Write elements of an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> into a buffer, inserting line
+breaks after every element.</p></li>
+</ul>
+<p>For the sake of argument, we’ll call it <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code>.</p>
+</section>
+<section id="the-development-environment">
+<h2>The development environment<a class="headerlink" href="#the-development-environment" title="Permalink to this heading">#</a></h2>
+<p>There are many excellent IDEs that can be used to develop C and C++
+libraries. For this tutorial, we will use
+<a class="reference external" href="https://code.visualstudio.com/">VSCode</a> and
+<a class="reference external" href="https://cmake.org/">CMake</a>. You’ll need both installed to follow
+along: VSCode can be downloaded from the official site for most
+platforms; CMake is typically installed via your favourite package
+manager (e.g., <code class="docutils literal notranslate"><span class="pre">brew</span> <span class="pre">install</span> <span class="pre">cmake</span></code>, <code class="docutils literal notranslate"><span class="pre">apt-get</span> <span class="pre">install</span> <span class="pre">cmake</span></code>,
+<code class="docutils literal notranslate"><span class="pre">dnf</span> <span class="pre">install</span> <span class="pre">cmake</span></code>, etc.). You will also need a C and C++ compiler:
+on MacOS these can be installed using <code class="docutils literal notranslate"><span class="pre">xcode-select</span> <span class="pre">--install</span></code>; on
+Linux you will need the packages that provide <code class="docutils literal notranslate"><span class="pre">gcc</span></code>, <code class="docutils literal notranslate"><span class="pre">g++</span></code>, and
+<code class="docutils literal notranslate"><span class="pre">make</span></code> (e.g., <code class="docutils literal notranslate"><span class="pre">apt-get</span> <span class="pre">install</span> <span class="pre">build-essential</span></code>); on Windows you
+will need to install <a class="reference external" href="https://visualstudio.microsoft.com/downloads/">Visual
+Studio</a> and CMake from
+the official download pages.</p>
+<p>Once you have VSCode installed, ensure you have the <strong>CMake Tools</strong> and
+<strong>C/C++</strong> extensions installed. Once your environment is set up, create
+a folder called <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code> and open it using <strong>File -> Open
+Folder</strong>.</p>
+</section>
+<section id="the-interface">
+<h2>The interface<a class="headerlink" href="#the-interface" title="Permalink to this heading">#</a></h2>
+<p>We’ll expose the interface to our library as a header called
+<code class="docutils literal notranslate"><span class="pre">linesplitter.h</span></code>. To ensure the definitions are only included once in
+any given source file, we’ll add the following line at the top:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#pragma once</span>
+</pre></div>
+</div>
+<p>Then, we need the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions">Arrow C Data
+interface</a>
+itself, since it provides the type definitions that are recognized by
+other Arrow implementations on which our API will be built. It’s
+designed to be copy and pasted in this way - there’s no need to put it
+in another file include something from another project.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><stdint.h></span>
+
+<span class="cp">#ifndef ARROW_C_DATA_INTERFACE</span>
+<span class="cp">#define ARROW_C_DATA_INTERFACE</span>
+
+<span class="cp">#define ARROW_FLAG_DICTIONARY_ORDERED 1</span>
+<span class="cp">#define ARROW_FLAG_NULLABLE 2</span>
+<span class="cp">#define ARROW_FLAG_MAP_KEYS_SORTED 4</span>
+
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="c1">// Array type description</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">format</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">name</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">metadata</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">flags</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">**</span><span class="w"> </span><span class="n">children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">dictionary</span><span class="p">;</span>
+
+<span class="w"> </span><span class="c1">// Release callback</span>
+<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="n">release</span><span class="p">)(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="p">);</span>
+<span class="w"> </span><span class="c1">// Opaque producer-specific data</span>
+<span class="w"> </span><span class="kt">void</span><span class="o">*</span><span class="w"> </span><span class="n">private_data</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="c1">// Array data description</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">length</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">null_count</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">offset</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_buffers</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="o">**</span><span class="w"> </span><span class="n">buffers</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">**</span><span class="w"> </span><span class="n">children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">dictionary</span><span class="p">;</span>
+
+<span class="w"> </span><span class="c1">// Release callback</span>
+<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="n">release</span><span class="p">)(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="p">);</span>
+<span class="w"> </span><span class="c1">// Opaque producer-specific data</span>
+<span class="w"> </span><span class="kt">void</span><span class="o">*</span><span class="w"> </span><span class="n">private_data</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="cp">#endif </span><span class="c1">// ARROW_C_DATA_INTERFACE</span>
+</pre></div>
+</div>
+<p>Next, we’ll provide definitions for the functions we’ll implement below:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="c1">// Builds an ArrowArray of type string that will contain one element for each line</span>
+<span class="c1">// in src and places it into out.</span>
+<span class="c1">//</span>
+<span class="c1">// On success, returns {0, ""}; on error, returns {<errno code>, <error message>}</span>
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">out</span><span class="p">);</span>
+
+<span class="c1">// Concatenates all elements of a string ArrowArray inserting a newline between</span>
+<span class="c1">// elements.</span>
+<span class="c1">//</span>
+<span class="c1">// On success, returns {0, <result>}; on error, returns {<errno code>, <error message>}</span>
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span [...]
+</pre></div>
+</div>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>You may notice that we don’t include or mention nanoarrow in any way in the header
+that is exposed to users. Because nanoarrow is designed to be vendored and is not
+distributed as a system library, it is not safe for users of your library to
+<code class="docutils literal notranslate"><span class="pre">#include</span> <span class="pre">"nanoarrow.h"</span></code> because it might conflict with another library that does
+the same (with possibly a different version of nanoarrow).</p>
+</div>
+</section>
+<section id="arrow-c-data-nanoarrow-interface-basics">
+<h2>Arrow C data/nanoarrow interface basics<a class="headerlink" href="#arrow-c-data-nanoarrow-interface-basics" title="Permalink to this heading">#</a></h2>
+<p>Now that we’ve seen the functions we need to implement and the Arrow
+types exposed in the C data interface, let’s unpack a few basics about
+using the Arrow C data interface and a few conventions used in the
+nanoarrow implementation.</p>
+<p>First, let’s discuss the <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> and the <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code>. You can
+think of an <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> as an expression of a data type, whereas an
+<code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> is the data itself. These structures accomodate nested
+types: columns are encoded in the <code class="docutils literal notranslate"><span class="pre">children</span></code> member of each. You
+always need to know the data type of an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> before accessing
+its contents. In our case we only operate on arrays of one type
+(“string”) and document that in our interface; for functions that
+operate on more than one type of array you will need to accept an
+<code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> and inspect it (e.g., using nanoarrow’s helper
+functions).</p>
+<p>Second, let’s discuss error handling. You may have noticed in the
+function definitions above that we return <code class="docutils literal notranslate"><span class="pre">int</span></code>, which is an
+errno-compatible error code or <code class="docutils literal notranslate"><span class="pre">0</span></code> to indicate success. Functions in
+nanoarrow that need to communicate more detailed error information
+accept an <code class="docutils literal notranslate"><span class="pre">ArrowError*</span></code> argument (which can be <code class="docutils literal notranslate"><span class="pre">NULL</span></code> if the caller
+does care about the extra information). Any nanoarrow function that
+might fail communicates errors in this way. To avoid verbose code like
+the following:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">int</span><span class="w"> </span><span class="nf">init_string_non_null</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">schema</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">code</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="n">schema</span><span class="o">-></span><span class="n">flags</span><span class="w"> </span><span class="o">&=</span><span class="w"> </span><span class="o">~</span><span class="n">ARROW_FLAG_NULLABLE</span><span class="p">;</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>…you can use the <code class="docutils literal notranslate"><span class="pre">NANOARROW_RETURN_NOT_OK()</span></code> macro:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">int</span><span class="w"> </span><span class="nf">init_string_non_null</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">schema</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="w"> </span><span class="n">schema</span><span class="o">-></span><span class="n">flags</span><span class="w"> </span><span class="o">&=</span><span class="w"> </span><span class="o">~</span><span class="n">ARROW_FLAG_NULLABLE</span><span class="p">;</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This works as long as your internal functions that use nanoarrow also
+return <code class="docutils literal notranslate"><span class="pre">int</span></code> and/or an <code class="docutils literal notranslate"><span class="pre">ArrowError*</span></code> argument. This usually means
+that there is an outer function that presents a more idiomatic interface
+(e.g., returning <code class="docutils literal notranslate"><span class="pre">std::optional<></span></code> or throwing an exception) and an
+inner function that uses nanoarrow-style error handling. Embracing
+<code class="docutils literal notranslate"><span class="pre">NANOARROW_RETURN_NOT_OK()</span></code> is key to hapiness when using the
+nanoarrow library.</p>
+<p>Third, let’s discuss memory management. Because nanoarrow is implemented
+in C and provides a C interface, the library by default uses C-style
+memory management (i.e., if you allocate it, you clean it up). This is
+unnecessary when you have C++ at your disposal, so nanoarrow also
+provides a C++ header (<code class="docutils literal notranslate"><span class="pre">nanoarrow.hpp</span></code>) with
+<code class="docutils literal notranslate"><span class="pre">std::unique_ptr<></span></code>-like wrappers around anything that requires
+explicit clean up. Whereas in C you might have to write code like this:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="w"> </span><span class="n">schema</span><span class="p">;</span>
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="w"> </span><span class="n">array</span><span class="p">;</span>
+
+<span class="c1">// Ok: if this returns, array was not initialized</span>
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+
+<span class="c1">// Verbose: if this fails, we need to release schema before returning</span>
+<span class="c1">// or it will leak.</span>
+<span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayInitFromSchema</span><span class="p">(</span><span class="o">&</span><span class="n">array</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="nb">NULL</span><span class="p">);</span>
+<span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">schema</span><span class="p">.</span><span class="n">release</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">);</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">code</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>…using the <code class="docutils literal notranslate"><span class="pre">nanoarrow.hpp</span></code> types we can do:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueSchema</span><span class="w"> </span><span class="n">schema</span><span class="p">;</span>
+<span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">array</span><span class="p">;</span>
+
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="n">schema</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayInitFromSchema</span><span class="p">(</span><span class="n">array</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">schema</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="nb">NULL</span><span class="p">));</span>
+</pre></div>
+</div>
+</section>
+<section id="building-the-library">
+<h2>Building the library<a class="headerlink" href="#building-the-library" title="Permalink to this heading">#</a></h2>
+<p>Our library implementation will live in <code class="docutils literal notranslate"><span class="pre">linesplitter.cc</span></code>. Before
+writing the actual implementations, let’s add just enough to our project
+that we can build it using VSCode’s C/C++/CMake integration:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><cerrno></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><cstdint></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><sstream></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><string></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><utility></span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow/nanoarrow.hpp"</span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"linesplitter.h"</span>
+
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">out</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">ENOTSUP</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="p">}</span>
+
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span [...]
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">ENOTSUP</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>We also need a <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code> file that tells CMake and VSCode what
+to build. CMake has a lot of options and can scale to coordinate very
+large projects; however we only need a few lines to leverage VSCode’s
+integration.</p>
+<div class="highlight-cmake notranslate"><div class="highlight"><pre><span></span><span class="nb">project</span><span class="p">(</span><span class="s">linesplitter</span><span class="p">)</span>
+
+<span class="nb">set</span><span class="p">(</span><span class="s">CMAKE_CXX_STANDARD</span><span class="w"> </span><span class="s">11</span><span class="p">)</span>
+
+<span class="nb">include</span><span class="p">(</span><span class="s">FetchContent</span><span class="p">)</span>
+
+<span class="nb">FetchContent_Declare</span><span class="p">(</span>
+<span class="w"> </span><span class="s">nanoarrow</span>
+<span class="w"> </span><span class="s">URL</span><span class="w"> </span><span class="s">https://github.com/apache/arrow-nanoarrow/releases/download/apache-arrow-nanoarrow-0.1.0/apache-arrow-nanoarrow-0.1.0.tar.gz</span>
+<span class="w"> </span><span class="s">URL_HASH</span><span class="w"> </span><span class="s">SHA512=dc62480b986ee76aaad8e38c6fbc602f8cef2cc35a5f5ede7da2a93b4db2b63839bdca3eefe8a44ae1cb6895a2fd3f090e3f6ea1020cf93cfe86437304dfee17</span><span class="p">)</span>
+<span class="nb">FetchContent_MakeAvailable</span><span class="p">(</span><span class="s">nanoarrow</span><span class="p">)</span>
+
+<span class="nb">add_library</span><span class="p">(</span><span class="s">linesplitter</span><span class="w"> </span><span class="s">linesplitter.cc</span><span class="p">)</span>
+<span class="nb">target_link_libraries</span><span class="p">(</span><span class="s">linesplitter</span><span class="w"> </span><span class="s">PRIVATE</span><span class="w"> </span><span class="s">nanoarrow</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>After saving <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code>, you may have to close and re-open the
+<code class="docutils literal notranslate"><span class="pre">linesplitter</span></code> directory in VSCode to activate the CMake integration.
+From the command pallete (i.e., Control/Command-Shift-P), choose
+<strong>CMake: Build</strong>. If all went well, you should see a few lines of output
+indicating progress towards building and linking <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code>.</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>Depending on your version of CMake you might also see a few warnings. This CMakeLists.txt
+is intentionally minimal and as such does not attempt to silence them.</p>
+</div>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>If you’re not using VSCode, you can accomplish the equivalent task in in a terminal
+with <code class="docutils literal notranslate"><span class="pre">mkdir</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">cd</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">cmake</span> <span class="pre">..</span> <span class="pre">&&</span> <span class="pre">cmake</span> <span class="pre">--build</span> <span class="pre">.</span></code>.</p>
+</div>
+</section>
+<section id="building-an-arrowarray">
+<h2>Building an ArrowArray<a class="headerlink" href="#building-an-arrowarray" title="Permalink to this heading">#</a></h2>
+<p>The input for our <code class="docutils literal notranslate"><span class="pre">linesplitter_read()</span></code> function in an
+<code class="docutils literal notranslate"><span class="pre">std::string</span></code>, which we’ll iterate over and add each detected line as
+its own element. First, some core logic to detect the number of
+characters until the next <code class="docutils literal notranslate"><span class="pre">\n</span></code> or end-of-string.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="nf">find_newline</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">ArrowStringView</span><span class="o">&</span><span class="w"> </span><span class="n">src</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">src</span><span class="p">.</span><span class="n">size [...]
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">src</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="sc">'\n'</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">i</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">src</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The next function we’ll define is an internal function that uses
+nanoarrow-style error handling. This uses the <code class="docutils literal notranslate"><span class="pre">ArrowArrayAppend*()</span></code>
+family of functions provided by nanoarrow to build the array:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">linesplitter_read_internal</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&</span><span class="w"> </span><span class="n">src</span><span class="p">,</span> [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="o">*</span><span class="w"> </span><span class="n">error</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">tmp</span><span class="p">;</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayInitFromType</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayStartAppending</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">()));</span>
+
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">src_view</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">src</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span><span class="w"> </span><span class="k">static_cast</span><span class="o"><</span><span class="kt">int64_t</span><span class="o">></span><span class="p">(</span><span cl [...]
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">line_view</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">-1</span><span class="p">;</span>
+<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="p">((</span><span class="n">next_newline</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find_newline</span><span class="p">(</span><span class="n">src_view</span><span class="p">))</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">line_view</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">src_view</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">next_newline</span><span class="p">};</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayAppendString</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">line_view</span><span class="p">));</span>
+<span class="w"> </span><span class="n">src_view</span><span class="p">.</span><span class="n">data</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
+<span class="w"> </span><span class="n">src_view</span><span class="p">.</span><span class="n">size_bytes</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayFinishBuildingDefault</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">error</span><span class="p">));</span>
+
+<span class="w"> </span><span class="n">ArrowArrayMove</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">out</span><span class="p">);</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Finally, we define a wrapper that corresponds to the outer function
+definition.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span cla [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_read_internal</span><span class="p">(</span><span class="n">src</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">error</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">ArrowErrorMessage</span><span class="p">(</span><span class="o">&</span><span class="n">error</span><span class="p">))};</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">NANOARROW_OK</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</section>
+<section id="reading-an-arrowarray">
+<h2>Reading an ArrowArray<a class="headerlink" href="#reading-an-arrowarray" title="Permalink to this heading">#</a></h2>
+<p>The input for our <code class="docutils literal notranslate"><span class="pre">linesplitter_write()</span></code> function is an
+<code class="docutils literal notranslate"><span class="pre">ArrowArray*</span></code> like the one we create in <code class="docutils literal notranslate"><span class="pre">linesplitter_read()</span></code>. Just
+as nanoarrow provides helpers to build arrays, it also provides helpers
+to read them via the <code class="docutils literal notranslate"><span class="pre">ArrowArrayView*()</span></code> family of functions. Again,
+we first define an internal function that uses nanoarrow-style error
+handling:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">linesplitter_write_internal</span><span class="p">(</span><span class="n">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">stringstr [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="o">*</span><span class="w"> </span><span class="n">error</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArrayView</span><span class="w"> </span><span class="n">input_view</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowArrayViewInitFromType</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayViewSetArray</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">error</span><span class="p">));</span>
+
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">item</span><span class="p">;</span>
+<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">input</span><span class="o">-></span><span class="n [...]
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">ArrowArrayViewIsNull</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">i</span><span class="p">))</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">out</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">i</span><span class="p">);</span>
+<span class="w"> </span><span class="n">out</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">)</span><span class="w"> </s [...]
+<span class="w"> </span><span class="p">}</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Then, provide an outer wrapper that corresponds to the outer function
+definition.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="n">ArrowArray</span><sp [...]
+<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">stringstream</span><span class="w"> </span><span class="n">out</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_write_internal</span><span class="p">(</span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">error</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">ArrowErrorMessage</span><span class="p">(</span><span class="o">&</span><span class="n">error</span><span class="p">))};</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">NANOARROW_OK</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span class="n">str</span><span class="p">()};</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</section>
+<section id="testing">
+<h2>Testing<a class="headerlink" href="#testing" title="Permalink to this heading">#</a></h2>
+<p>We have an implementation, but does it work? Unlike higher-level
+runtimes like R and Python, we can’t just open a prompt and type some
+code to find out. For C and C++ libraries, the
+<a class="reference external" href="https://google.github.io/googletest/quickstart-cmake.html">googletest</a>
+framework provides a quick and easy way to do this that scales nicely as
+the complexity of your project grows.</p>
+<p>First, we’ll add a stub test and some CMake to get going. In
+<code class="docutils literal notranslate"><span class="pre">linesplitter_test.cc</span></code>, add the following:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><gtest/gtest.h></span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow/nanoarrow.hpp"</span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"linesplitter.h"</span>
+
+<span class="n">TEST</span><span class="p">(</span><span class="n">Linesplitter</span><span class="p">,</span><span class="w"> </span><span class="n">LinesplitterRoundtrip</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">EXPECT_EQ</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Then, add the following to your <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code>:</p>
+<div class="highlight-cmake notranslate"><div class="highlight"><pre><span></span><span class="nb">FetchContent_Declare</span><span class="p">(</span>
+<span class="w"> </span><span class="s">googletest</span>
+<span class="w"> </span><span class="s">URL</span><span class="w"> </span><span class="s">https://github.com/google/googletest/archive/refs/tags/v1.13.0.zip</span>
+<span class="p">)</span>
+<span class="nb">FetchContent_MakeAvailable</span><span class="p">(</span><span class="s">googletest</span><span class="p">)</span>
+
+<span class="nb">enable_testing</span><span class="p">()</span>
+
+<span class="nb">add_executable</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="w"> </span><span class="s">linesplitter_test.cc</span><span class="p">)</span>
+<span class="nb">target_link_libraries</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="w"> </span><span class="s">linesplitter</span><span class="w"> </span><span class="s">GTest::gtest_main</span><span class="p">)</span>
+
+<span class="nb">include</span><span class="p">(</span><span class="s">GoogleTest</span><span class="p">)</span>
+<span class="nb">gtest_discover_tests</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>After you’re done, build the project again using the <strong>CMake: Build</strong>
+command from the command palette. If all goes well, choose <strong>Test: Run
+All Tests</strong> from the command pallete to run them! You should see some
+output indiciating that tests ran successfully, or you can use VSCode’s
+“Testing” panel to visually inspect which tests passed.</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>If you’re not using VSCode, you can accomplish the equivalent task in in a terminal
+with <code class="docutils literal notranslate"><span class="pre">cd</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">ctest</span> <span class="pre">.</span></code>.</p>
+</div>
+<p>Now we’re ready to fill in the test! Our two functions happen to round
+trip, so a useful first test might be to check.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">TEST</span><span class="p">(</span><span class="n">Linesplitter</span><span class="p">,</span><span class="w"> </span><span class="n">LinesplitterRoundtrip</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">out</span><span class="p">;</span>
+<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="s">"line1</span><span class="se">\n</span><span class="s">line2</span><span class="se">\n</span><span class="s">line3"</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span [...]
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">second</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">);</span>
+
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">out</span><span class="o">-></span><span class="n">length</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">);</span>
+
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArrayView</span><span class="w"> </span><span class="n">out_view</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowArrayViewInitFromType</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">ArrowArrayViewSetArray</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="k">nullptr</span><span class="p">),</span><span class="w"> </span><span [...]
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">item</span><span class="p">;</span>
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line1"</span><span cl [...]
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line2"</span><span cl [...]
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">2</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line3"</span><span cl [...]
+
+
+<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">result2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="n">out</span><span class="p">.</span><span class="n">get</span><span class="p">());</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result2</span><span class="p">.</span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result2</span><span class="p">.</span><span class="n">second</span><span class="p">,</span><span class="w"> </span><span class="s">"line1</span><span class="se">\n</span><span class="s">line2</span><span class="se">\n</span><span class="s">line3</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Writing tests in this way also opens up a relatively straightforward
+debug path via the <strong>CMake: Set Debug target</strong> and <strong>CMake: Debug</strong>
+commands. If the first thing that happens when you write run your test
+is a crash, running the tests with the debugger turned on will
+automatically pause at the line of code that caused the crash. For more
+fine-tuned debugging, you can set breakpoints and step through code.</p>
+</section>
+<section id="summary">
+<h2>Summary<a class="headerlink" href="#summary" title="Permalink to this heading">#</a></h2>
+<p>This tutorial covered the basics of writing and testing a C++ library
+exposing an Arrow-based API implemented using the nanoarrow C library.</p>
+</section>
+</section>
+
+
+ </article>
+
+
+
+ <footer class="bd-footer-article">
+
+<div class="footer-article-items footer-article__inner">
+
+ <div class="footer-article-item"><!-- Previous / next buttons -->
+<div class="prev-next-area">
+ <a class="left-prev"
+ href="index.html"
+ title="previous page">
+ <i class="fa-solid fa-angle-left"></i>
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">previous</p>
+ <p class="prev-next-title">nanoarrow</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="c.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">C API Reference</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div></div>
+
+</div>
+
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+ <div class="sidebar-secondary-item">
+ <div class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-library">The library</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-development-environment">The development environment</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-interface">The interface</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrow-c-data-nanoarrow-interface-basics">Arrow C data/nanoarrow interface basics</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#building-the-library">Building the library</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#building-an-arrowarray">Building an ArrowArray</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#reading-an-arrowarray">Reading an ArrowArray</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#testing">Testing</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#summary">Summary</a></li>
+</ul>
+ </nav></div>
+
+ <div class="sidebar-secondary-item">
+
+ <div class="tocsection editthispage">
+ <a href="https://github.com/apache/arrow-nanoarrow/edit/main/docs/source/getting-started.rst">
+ <i class="fa-solid fa-pencil"></i>
+
+
+
+ Edit on GitHub
+
+
+ </a>
+ </div>
+</div>
+
+ <div class="sidebar-secondary-item">
+ <div class="tocsection sourcelink">
+ <a href="_sources/getting-started.rst.txt">
+ <i class="fa-solid fa-file-lines"></i> Show Source
+ </a>
+ </div>
+</div>
+
+</div></div>
+
+
+ </div>
+ <footer class="bd-footer-content">
+
+ </footer>
+
+ </main>
+ </div>
+ </div>
+
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="_static/scripts/bootstrap.js?digest=e353d410970836974a52"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52"></script>
+
+ <footer class="bd-footer">
+<div class="bd-footer__inner bd-page-width">
+
+ <div class="footer-items__start">
+
+ <div class="footer-item">
+ <p class="copyright">
+
+ © Copyright 2016-2023 Apache Software Foundation.
+ <br/>
+
+ </p>
+</div>
+
+ <div class="footer-item">
+ <p class="sphinx-version">
+ Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.0.1.
+ <br/>
+ </p>
+</div>
+
+ </div>
+
+
+ <div class="footer-items__end">
+
+ <div class="footer-item"><p class="theme-version">
+ Built with the <a href="https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html">PyData Sphinx Theme</a> 0.13.3.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/0.2.0/getting-started_generated.html b/0.2.0/getting-started_generated.html
new file mode 100644
index 0000000..ee6c2ac
--- /dev/null
+++ b/0.2.0/getting-started_generated.html
@@ -0,0 +1,978 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+
+ <title>Getting started with nanoarrow — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started_generated';</script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="index.html">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+ <div class="navbar-header-items__end">
+
+ <div class="navbar-item navbar-persistent--container">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn search-button search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ </button>
+`);
+</script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </nav>
+
+ <div class="bd-container">
+ <div class="bd-container__inner bd-page-width">
+
+ <div class="bd-sidebar-primary bd-sidebar">
+
+
+
+ <div class="sidebar-header-items sidebar-primary__section">
+
+
+ <div class="sidebar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="c.html">
+ C API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="cpp.html">
+ C++ API Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="ipc.html">
+ IPC Extension Reference
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-external" href="r/index.html">
+ R Package
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+<script>
+document.write(`
+ <button class="theme-switch-button btn btn-sm btn-outline-primary navbar-btn rounded-circle" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch" data-mode="light"><i class="fa-solid fa-sun"></i></span>
+ <span class="theme-switch" data-mode="dark"><i class="fa-solid fa-moon"></i></span>
+ <span class="theme-switch" data-mode="auto"><i class="fa-solid fa-circle-half-stroke"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+ <div class="sidebar-primary-items__start sidebar-primary__section">
+ <div class="sidebar-primary-item">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+
+ <div class="sidebar-primary-items__end sidebar-primary__section">
+ </div>
+
+ <div id="rtd-footer-container"></div>
+
+
+ </div>
+
+ <main id="main-content" class="bd-main">
+
+
+ <div class="bd-content">
+ <div class="bd-article-container">
+
+ <div class="bd-header-article">
+<div class="header-article-items header-article__inner">
+
+ <div class="header-article-items__start">
+
+ <div class="header-article-item">
+
+
+
+<nav aria-label="Breadcrumbs">
+ <ul class="bd-breadcrumbs" role="navigation" aria-label="Breadcrumb">
+
+ <li class="breadcrumb-item breadcrumb-home">
+ <a href="index.html" class="nav-link" aria-label="Home">
+ <i class="fa-solid fa-home"></i>
+ </a>
+ </li>
+ <li class="breadcrumb-item active" aria-current="page">Getting started with nanoarrow</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article" role="main">
+
+ <!---
+ 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.
+--><section id="getting-started-with-nanoarrow">
+<h1>Getting started with nanoarrow<a class="headerlink" href="#getting-started-with-nanoarrow" title="Permalink to this heading">#</a></h1>
+<p>This tutorial provides a short example of writing a C++ library that
+exposes an Arrow-based API and uses nanoarrow to implement a simple text
+file reader/writer. In general, nanoarrow can help you write a library
+or application that:</p>
+<ul class="simple">
+<li><p>exposes an Arrow-based API to read from a data source or format,</p></li>
+<li><p>exposes an Arrow-based API to write to a data source or format,</p></li>
+<li><p>exposes one or more compute functions that operates on and produces
+data in the form of Arrow arrays, and/or</p></li>
+<li><p>exposes an extension type implementation.</p></li>
+</ul>
+<p>Becauase Arrow has bindings in many languages, it means that you or
+others can easily bind or use your tool in higher-level runtimes like R,
+Java, C++, Python, Rust, Julia, Go, or Ruby, among others.</p>
+<p>The nanoarrow library is not the only way that an Arrow-based API can be
+implemented: Arrow C++, Rust, and Go are all excellent choices and can
+compile into static libraries that are C-linkable from other languages;
+however, existing Arrow implementations produce relatively large static
+libraries and can present complex build-time or run-time linking
+requirements depending on the implementation and features used. If the
+set of libraries you’re working with already provide the conveniences
+you require, nanoarrow may provide all the functionality you need.</p>
+<p>Now that we’ve talked about why you might want to build a library with
+nanoarrow…let’s build one!</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>This tutorial also goes over some of the basic structure of writing a C++ library.
+If you already know how to do this, feel free to scroll to the code examples provided
+below or take a look at the
+<a class="reference external" href="https://github.com/apache/arrow-nanoarrow/tree/main/examples/linesplitter">final example project</a>.</p>
+</div>
+<section id="the-library">
+<h2>The library<a class="headerlink" href="#the-library" title="Permalink to this heading">#</a></h2>
+<p>The library we’ll write in this tutorial is a simple text processing
+library that splits and reassembles lines of text. It will be able to:</p>
+<ul class="simple">
+<li><p>Read text from a buffer into an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> as one element per
+line, and</p></li>
+<li><p>Write elements of an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> into a buffer, inserting line
+breaks after every element.</p></li>
+</ul>
+<p>For the sake of argument, we’ll call it <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code>.</p>
+</section>
+<section id="the-development-environment">
+<h2>The development environment<a class="headerlink" href="#the-development-environment" title="Permalink to this heading">#</a></h2>
+<p>There are many excellent IDEs that can be used to develop C and C++
+libraries. For this tutorial, we will use
+<a class="reference external" href="https://code.visualstudio.com/">VSCode</a> and
+<a class="reference external" href="https://cmake.org/">CMake</a>. You’ll need both installed to follow
+along: VSCode can be downloaded from the official site for most
+platforms; CMake is typically installed via your favourite package
+manager (e.g., <code class="docutils literal notranslate"><span class="pre">brew</span> <span class="pre">install</span> <span class="pre">cmake</span></code>, <code class="docutils literal notranslate"><span class="pre">apt-get</span> <span class="pre">install</span> <span class="pre">cmake</span></code>,
+<code class="docutils literal notranslate"><span class="pre">dnf</span> <span class="pre">install</span> <span class="pre">cmake</span></code>, etc.). You will also need a C and C++ compiler:
+on MacOS these can be installed using <code class="docutils literal notranslate"><span class="pre">xcode-select</span> <span class="pre">--install</span></code>; on
+Linux you will need the packages that provide <code class="docutils literal notranslate"><span class="pre">gcc</span></code>, <code class="docutils literal notranslate"><span class="pre">g++</span></code>, and
+<code class="docutils literal notranslate"><span class="pre">make</span></code> (e.g., <code class="docutils literal notranslate"><span class="pre">apt-get</span> <span class="pre">install</span> <span class="pre">build-essential</span></code>); on Windows you
+will need to install <a class="reference external" href="https://visualstudio.microsoft.com/downloads/">Visual
+Studio</a> and CMake from
+the official download pages.</p>
+<p>Once you have VSCode installed, ensure you have the <strong>CMake Tools</strong> and
+<strong>C/C++</strong> extensions installed. Once your environment is set up, create
+a folder called <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code> and open it using <strong>File -> Open
+Folder</strong>.</p>
+</section>
+<section id="the-interface">
+<h2>The interface<a class="headerlink" href="#the-interface" title="Permalink to this heading">#</a></h2>
+<p>We’ll expose the interface to our library as a header called
+<code class="docutils literal notranslate"><span class="pre">linesplitter.h</span></code>. To ensure the definitions are only included once in
+any given source file, we’ll add the following line at the top:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#pragma once</span>
+</pre></div>
+</div>
+<p>Then, we need the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions">Arrow C Data
+interface</a>
+itself, since it provides the type definitions that are recognized by
+other Arrow implementations on which our API will be built. It’s
+designed to be copy and pasted in this way - there’s no need to put it
+in another file include something from another project.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><stdint.h></span>
+
+<span class="cp">#ifndef ARROW_C_DATA_INTERFACE</span>
+<span class="cp">#define ARROW_C_DATA_INTERFACE</span>
+
+<span class="cp">#define ARROW_FLAG_DICTIONARY_ORDERED 1</span>
+<span class="cp">#define ARROW_FLAG_NULLABLE 2</span>
+<span class="cp">#define ARROW_FLAG_MAP_KEYS_SORTED 4</span>
+
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="c1">// Array type description</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">format</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">name</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">metadata</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">flags</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">**</span><span class="w"> </span><span class="n">children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">dictionary</span><span class="p">;</span>
+
+<span class="w"> </span><span class="c1">// Release callback</span>
+<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="n">release</span><span class="p">)(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="p">);</span>
+<span class="w"> </span><span class="c1">// Opaque producer-specific data</span>
+<span class="w"> </span><span class="kt">void</span><span class="o">*</span><span class="w"> </span><span class="n">private_data</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="c1">// Array data description</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">length</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">null_count</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">offset</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_buffers</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">n_children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="o">**</span><span class="w"> </span><span class="n">buffers</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">**</span><span class="w"> </span><span class="n">children</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">dictionary</span><span class="p">;</span>
+
+<span class="w"> </span><span class="c1">// Release callback</span>
+<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="n">release</span><span class="p">)(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="p">);</span>
+<span class="w"> </span><span class="c1">// Opaque producer-specific data</span>
+<span class="w"> </span><span class="kt">void</span><span class="o">*</span><span class="w"> </span><span class="n">private_data</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="cp">#endif </span><span class="c1">// ARROW_C_DATA_INTERFACE</span>
+</pre></div>
+</div>
+<p>Next, we’ll provide definitions for the functions we’ll implement below:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="c1">// Builds an ArrowArray of type string that will contain one element for each line</span>
+<span class="c1">// in src and places it into out.</span>
+<span class="c1">//</span>
+<span class="c1">// On success, returns {0, ""}; on error, returns {<errno code>, <error message>}</span>
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">out</span><span class="p">);</span>
+
+<span class="c1">// Concatenates all elements of a string ArrowArray inserting a newline between</span>
+<span class="c1">// elements.</span>
+<span class="c1">//</span>
+<span class="c1">// On success, returns {0, <result>}; on error, returns {<errno code>, <error message>}</span>
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span [...]
+</pre></div>
+</div>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>You may notice that we don’t include or mention nanoarrow in any way in the header
+that is exposed to users. Because nanoarrow is designed to be vendored and is not
+distributed as a system library, it is not safe for users of your library to
+<code class="docutils literal notranslate"><span class="pre">#include</span> <span class="pre">"nanoarrow.h"</span></code> because it might conflict with another library that does
+the same (with possibly a different version of nanoarrow).</p>
+</div>
+</section>
+<section id="arrow-c-data-nanoarrow-interface-basics">
+<h2>Arrow C data/nanoarrow interface basics<a class="headerlink" href="#arrow-c-data-nanoarrow-interface-basics" title="Permalink to this heading">#</a></h2>
+<p>Now that we’ve seen the functions we need to implement and the Arrow
+types exposed in the C data interface, let’s unpack a few basics about
+using the Arrow C data interface and a few conventions used in the
+nanoarrow implementation.</p>
+<p>First, let’s discuss the <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> and the <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code>. You can
+think of an <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> as an expression of a data type, whereas an
+<code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> is the data itself. These structures accomodate nested
+types: columns are encoded in the <code class="docutils literal notranslate"><span class="pre">children</span></code> member of each. You
+always need to know the data type of an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> before accessing
+its contents. In our case we only operate on arrays of one type
+(“string”) and document that in our interface; for functions that
+operate on more than one type of array you will need to accept an
+<code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> and inspect it (e.g., using nanoarrow’s helper
+functions).</p>
+<p>Second, let’s discuss error handling. You may have noticed in the
+function definitions above that we return <code class="docutils literal notranslate"><span class="pre">int</span></code>, which is an
+errno-compatible error code or <code class="docutils literal notranslate"><span class="pre">0</span></code> to indicate success. Functions in
+nanoarrow that need to communicate more detailed error information
+accept an <code class="docutils literal notranslate"><span class="pre">ArrowError*</span></code> argument (which can be <code class="docutils literal notranslate"><span class="pre">NULL</span></code> if the caller
+does care about the extra information). Any nanoarrow function that
+might fail communicates errors in this way. To avoid verbose code like
+the following:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">int</span><span class="w"> </span><span class="nf">init_string_non_null</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">schema</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">code</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="n">schema</span><span class="o">-></span><span class="n">flags</span><span class="w"> </span><span class="o">&=</span><span class="w"> </span><span class="o">~</span><span class="n">ARROW_FLAG_NULLABLE</span><span class="p">;</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>…you can use the <code class="docutils literal notranslate"><span class="pre">NANOARROW_RETURN_NOT_OK()</span></code> macro:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="kt">int</span><span class="w"> </span><span class="nf">init_string_non_null</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="o">*</span><span class="w"> </span><span class="n">schema</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="w"> </span><span class="n">schema</span><span class="o">-></span><span class="n">flags</span><span class="w"> </span><span class="o">&=</span><span class="w"> </span><span class="o">~</span><span class="n">ARROW_FLAG_NULLABLE</span><span class="p">;</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>This works as long as your internal functions that use nanoarrow also
+return <code class="docutils literal notranslate"><span class="pre">int</span></code> and/or an <code class="docutils literal notranslate"><span class="pre">ArrowError*</span></code> argument. This usually means
+that there is an outer function that presents a more idiomatic interface
+(e.g., returning <code class="docutils literal notranslate"><span class="pre">std::optional<></span></code> or throwing an exception) and an
+inner function that uses nanoarrow-style error handling. Embracing
+<code class="docutils literal notranslate"><span class="pre">NANOARROW_RETURN_NOT_OK()</span></code> is key to hapiness when using the
+nanoarrow library.</p>
+<p>Third, let’s discuss memory management. Because nanoarrow is implemented
+in C and provides a C interface, the library by default uses C-style
+memory management (i.e., if you allocate it, you clean it up). This is
+unnecessary when you have C++ at your disposal, so nanoarrow also
+provides a C++ header (<code class="docutils literal notranslate"><span class="pre">nanoarrow.hpp</span></code>) with
+<code class="docutils literal notranslate"><span class="pre">std::unique_ptr<></span></code>-like wrappers around anything that requires
+explicit clean up. Whereas in C you might have to write code like this:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowSchema</span><span class="w"> </span><span class="n">schema</span><span class="p">;</span>
+<span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="w"> </span><span class="n">array</span><span class="p">;</span>
+
+<span class="c1">// Ok: if this returns, array was not initialized</span>
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+
+<span class="c1">// Verbose: if this fails, we need to release schema before returning</span>
+<span class="c1">// or it will leak.</span>
+<span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayInitFromSchema</span><span class="p">(</span><span class="o">&</span><span class="n">array</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">schema</span><span class="p">,</span><span class="w"> </span><span class="nb">NULL</span><span class="p">);</span>
+<span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">schema</span><span class="p">.</span><span class="n">release</span><span class="p">(</span><span class="o">&</span><span class="n">schema</span><span class="p">);</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">code</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>…using the <code class="docutils literal notranslate"><span class="pre">nanoarrow.hpp</span></code> types we can do:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueSchema</span><span class="w"> </span><span class="n">schema</span><span class="p">;</span>
+<span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">array</span><span class="p">;</span>
+
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="n">schema</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayInitFromSchema</span><span class="p">(</span><span class="n">array</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">schema</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="nb">NULL</span><span class="p">));</span>
+</pre></div>
+</div>
+</section>
+<section id="building-the-library">
+<h2>Building the library<a class="headerlink" href="#building-the-library" title="Permalink to this heading">#</a></h2>
+<p>Our library implementation will live in <code class="docutils literal notranslate"><span class="pre">linesplitter.cc</span></code>. Before
+writing the actual implementations, let’s add just enough to our project
+that we can build it using VSCode’s C/C++/CMake integration:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><cerrno></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><cstdint></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><sstream></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><string></span>
+<span class="cp">#include</span><span class="w"> </span><span class="cpf"><utility></span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow/nanoarrow.hpp"</span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"linesplitter.h"</span>
+
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">out</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">ENOTSUP</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="p">}</span>
+
+<span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArray</span><span class="o">*</span><span [...]
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">ENOTSUP</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>We also need a <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code> file that tells CMake and VSCode what
+to build. CMake has a lot of options and can scale to coordinate very
+large projects; however we only need a few lines to leverage VSCode’s
+integration.</p>
+<div class="highlight-cmake notranslate"><div class="highlight"><pre><span></span><span class="nb">project</span><span class="p">(</span><span class="s">linesplitter</span><span class="p">)</span>
+
+<span class="nb">set</span><span class="p">(</span><span class="s">CMAKE_CXX_STANDARD</span><span class="w"> </span><span class="s">11</span><span class="p">)</span>
+
+<span class="nb">include</span><span class="p">(</span><span class="s">FetchContent</span><span class="p">)</span>
+
+<span class="nb">FetchContent_Declare</span><span class="p">(</span>
+<span class="w"> </span><span class="s">nanoarrow</span>
+<span class="w"> </span><span class="s">URL</span><span class="w"> </span><span class="s">https://github.com/apache/arrow-nanoarrow/releases/download/apache-arrow-nanoarrow-0.1.0/apache-arrow-nanoarrow-0.1.0.tar.gz</span>
+<span class="w"> </span><span class="s">URL_HASH</span><span class="w"> </span><span class="s">SHA512=dc62480b986ee76aaad8e38c6fbc602f8cef2cc35a5f5ede7da2a93b4db2b63839bdca3eefe8a44ae1cb6895a2fd3f090e3f6ea1020cf93cfe86437304dfee17</span><span class="p">)</span>
+<span class="nb">FetchContent_MakeAvailable</span><span class="p">(</span><span class="s">nanoarrow</span><span class="p">)</span>
+
+<span class="nb">add_library</span><span class="p">(</span><span class="s">linesplitter</span><span class="w"> </span><span class="s">linesplitter.cc</span><span class="p">)</span>
+<span class="nb">target_link_libraries</span><span class="p">(</span><span class="s">linesplitter</span><span class="w"> </span><span class="s">PRIVATE</span><span class="w"> </span><span class="s">nanoarrow</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>After saving <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code>, you may have to close and re-open the
+<code class="docutils literal notranslate"><span class="pre">linesplitter</span></code> directory in VSCode to activate the CMake integration.
+From the command pallete (i.e., Control/Command-Shift-P), choose
+<strong>CMake: Build</strong>. If all went well, you should see a few lines of output
+indicating progress towards building and linking <code class="docutils literal notranslate"><span class="pre">linesplitter</span></code>.</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>Depending on your version of CMake you might also see a few warnings. This CMakeLists.txt
+is intentionally minimal and as such does not attempt to silence them.</p>
+</div>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>If you’re not using VSCode, you can accomplish the equivalent task in in a terminal
+with <code class="docutils literal notranslate"><span class="pre">mkdir</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">cd</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">cmake</span> <span class="pre">..</span> <span class="pre">&&</span> <span class="pre">cmake</span> <span class="pre">--build</span> <span class="pre">.</span></code>.</p>
+</div>
+</section>
+<section id="building-an-arrowarray">
+<h2>Building an ArrowArray<a class="headerlink" href="#building-an-arrowarray" title="Permalink to this heading">#</a></h2>
+<p>The input for our <code class="docutils literal notranslate"><span class="pre">linesplitter_read()</span></code> function in an
+<code class="docutils literal notranslate"><span class="pre">std::string</span></code>, which we’ll iterate over and add each detected line as
+its own element. First, some core logic to detect the number of
+characters until the next <code class="docutils literal notranslate"><span class="pre">\n</span></code> or end-of-string.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="nf">find_newline</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">ArrowStringView</span><span class="o">&</span><span class="w"> </span><span class="n">src</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">src</span><span class="p">.</span><span class="n">size [...]
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">src</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="sc">'\n'</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">i</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">src</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>The next function we’ll define is an internal function that uses
+nanoarrow-style error handling. This uses the <code class="docutils literal notranslate"><span class="pre">ArrowArrayAppend*()</span></code>
+family of functions provided by nanoarrow to build the array:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">linesplitter_read_internal</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">&</span><span class="w"> </span><span class="n">src</span><span class="p">,</span> [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="o">*</span><span class="w"> </span><span class="n">error</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">tmp</span><span class="p">;</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayInitFromType</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">));</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayStartAppending</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">()));</span>
+
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">src_view</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">src</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span><span class="w"> </span><span class="k">static_cast</span><span class="o"><</span><span class="kt">int64_t</span><span class="o">></span><span class="p">(</span><span cl [...]
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">line_view</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int64_t</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">-1</span><span class="p">;</span>
+<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="p">((</span><span class="n">next_newline</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">find_newline</span><span class="p">(</span><span class="n">src_view</span><span class="p">))</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">line_view</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">src_view</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">next_newline</span><span class="p">};</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayAppendString</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">line_view</span><span class="p">));</span>
+<span class="w"> </span><span class="n">src_view</span><span class="p">.</span><span class="n">data</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
+<span class="w"> </span><span class="n">src_view</span><span class="p">.</span><span class="n">size_bytes</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="n">next_newline</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayFinishBuildingDefault</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">error</span><span class="p">));</span>
+
+<span class="w"> </span><span class="n">ArrowArrayMove</span><span class="p">(</span><span class="n">tmp</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">out</span><span class="p">);</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Finally, we define a wrapper that corresponds to the outer function
+definition.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="k">const</span><span cla [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_read_internal</span><span class="p">(</span><span class="n">src</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">error</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">ArrowErrorMessage</span><span class="p">(</span><span class="o">&</span><span class="n">error</span><span class="p">))};</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">NANOARROW_OK</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">};</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</section>
+<section id="reading-an-arrowarray">
+<h2>Reading an ArrowArray<a class="headerlink" href="#reading-an-arrowarray" title="Permalink to this heading">#</a></h2>
+<p>The input for our <code class="docutils literal notranslate"><span class="pre">linesplitter_write()</span></code> function is an
+<code class="docutils literal notranslate"><span class="pre">ArrowArray*</span></code> like the one we create in <code class="docutils literal notranslate"><span class="pre">linesplitter_read()</span></code>. Just
+as nanoarrow provides helpers to build arrays, it also provides helpers
+to read them via the <code class="docutils literal notranslate"><span class="pre">ArrowArrayView*()</span></code> family of functions. Again,
+we first define an internal function that uses nanoarrow-style error
+handling:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="k">static</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">linesplitter_write_internal</span><span class="p">(</span><span class="n">ArrowArray</span><span class="o">*</span><span class="w"> </span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">stringstr [...]
+<span class="w"> </span><span class="n">ArrowError</span><span class="o">*</span><span class="w"> </span><span class="n">error</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArrayView</span><span class="w"> </span><span class="n">input_view</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowArrayViewInitFromType</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayViewSetArray</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">error</span><span class="p">));</span>
+
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">item</span><span class="p">;</span>
+<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int64_t</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="n">input</span><span class="o">-></span><span class="n [...]
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">ArrowArrayViewIsNull</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">i</span><span class="p">))</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">out</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">input_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">i</span><span class="p">);</span>
+<span class="w"> </span><span class="n">out</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">)</span><span class="w"> </s [...]
+<span class="w"> </span><span class="p">}</span>
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Then, provide an outer wrapper that corresponds to the outer function
+definition.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="n">ArrowArray</span><sp [...]
+<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">stringstream</span><span class="w"> </span><span class="n">out</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_write_internal</span><span class="p">(</span><span class="n">input</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">error</span><span class="p">);</span>
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">code</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_OK</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">ArrowErrorMessage</span><span class="p">(</span><span class="o">&</span><span class="n">error</span><span class="p">))};</span>
+<span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">{</span><span class="n">NANOARROW_OK</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span class="n">str</span><span class="p">()};</span>
+<span class="w"> </span><span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</section>
+<section id="testing">
+<h2>Testing<a class="headerlink" href="#testing" title="Permalink to this heading">#</a></h2>
+<p>We have an implementation, but does it work? Unlike higher-level
+runtimes like R and Python, we can’t just open a prompt and type some
+code to find out. For C and C++ libraries, the
+<a class="reference external" href="https://google.github.io/googletest/quickstart-cmake.html">googletest</a>
+framework provides a quick and easy way to do this that scales nicely as
+the complexity of your project grows.</p>
+<p>First, we’ll add a stub test and some CMake to get going. In
+<code class="docutils literal notranslate"><span class="pre">linesplitter_test.cc</span></code>, add the following:</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><gtest/gtest.h></span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow/nanoarrow.hpp"</span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"linesplitter.h"</span>
+
+<span class="n">TEST</span><span class="p">(</span><span class="n">Linesplitter</span><span class="p">,</span><span class="w"> </span><span class="n">LinesplitterRoundtrip</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">EXPECT_EQ</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Then, add the following to your <code class="docutils literal notranslate"><span class="pre">CMakeLists.txt</span></code>:</p>
+<div class="highlight-cmake notranslate"><div class="highlight"><pre><span></span><span class="nb">FetchContent_Declare</span><span class="p">(</span>
+<span class="w"> </span><span class="s">googletest</span>
+<span class="w"> </span><span class="s">URL</span><span class="w"> </span><span class="s">https://github.com/google/googletest/archive/refs/tags/v1.13.0.zip</span>
+<span class="p">)</span>
+<span class="nb">FetchContent_MakeAvailable</span><span class="p">(</span><span class="s">googletest</span><span class="p">)</span>
+
+<span class="nb">enable_testing</span><span class="p">()</span>
+
+<span class="nb">add_executable</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="w"> </span><span class="s">linesplitter_test.cc</span><span class="p">)</span>
+<span class="nb">target_link_libraries</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="w"> </span><span class="s">linesplitter</span><span class="w"> </span><span class="s">GTest::gtest_main</span><span class="p">)</span>
+
+<span class="nb">include</span><span class="p">(</span><span class="s">GoogleTest</span><span class="p">)</span>
+<span class="nb">gtest_discover_tests</span><span class="p">(</span><span class="s">linesplitter_test</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>After you’re done, build the project again using the <strong>CMake: Build</strong>
+command from the command palette. If all goes well, choose <strong>Test: Run
+All Tests</strong> from the command pallete to run them! You should see some
+output indiciating that tests ran successfully, or you can use VSCode’s
+“Testing” panel to visually inspect which tests passed.</p>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>If you’re not using VSCode, you can accomplish the equivalent task in in a terminal
+with <code class="docutils literal notranslate"><span class="pre">cd</span> <span class="pre">build</span> <span class="pre">&&</span> <span class="pre">ctest</span> <span class="pre">.</span></code>.</p>
+</div>
+<p>Now we’re ready to fill in the test! Our two functions happen to round
+trip, so a useful first test might be to check.</p>
+<div class="highlight-cpp notranslate"><div class="highlight"><pre><span></span><span class="n">TEST</span><span class="p">(</span><span class="n">Linesplitter</span><span class="p">,</span><span class="w"> </span><span class="n">LinesplitterRoundtrip</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArray</span><span class="w"> </span><span class="n">out</span><span class="p">;</span>
+<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_read</span><span class="p">(</span><span class="s">"line1</span><span class="se">\n</span><span class="s">line2</span><span class="se">\n</span><span class="s">line3"</span><span class="p">,</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span [...]
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result</span><span class="p">.</span><span class="n">second</span><span class="p">,</span><span class="w"> </span><span class="s">""</span><span class="p">);</span>
+
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">out</span><span class="o">-></span><span class="n">length</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">);</span>
+
+<span class="w"> </span><span class="n">nanoarrow</span><span class="o">::</span><span class="n">UniqueArrayView</span><span class="w"> </span><span class="n">out_view</span><span class="p">;</span>
+<span class="w"> </span><span class="n">ArrowArrayViewInitFromType</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">NANOARROW_TYPE_STRING</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">ArrowArrayViewSetArray</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="n">out</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="k">nullptr</span><span class="p">),</span><span class="w"> </span><span [...]
+<span class="w"> </span><span class="n">ArrowStringView</span><span class="w"> </span><span class="n">item</span><span class="p">;</span>
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line1"</span><span cl [...]
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line2"</span><span cl [...]
+
+<span class="w"> </span><span class="n">item</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ArrowArrayViewGetStringUnsafe</span><span class="p">(</span><span class="n">out_view</span><span class="p">.</span><span class="n">get</span><span class="p">(),</span><span class="w"> </span><span class="mi">2</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="n">item</span><span class="p">.</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">item</span><span class="p">.</span><span class="n">size_bytes</span><span class="p">),</span><span class="w"> </span><span class="s">"line3"</span><span cl [...]
+
+
+<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">result2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">linesplitter_write</span><span class="p">(</span><span class="n">out</span><span class="p">.</span><span class="n">get</span><span class="p">());</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result2</span><span class="p">.</span><span class="n">first</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
+<span class="w"> </span><span class="n">ASSERT_EQ</span><span class="p">(</span><span class="n">result2</span><span class="p">.</span><span class="n">second</span><span class="p">,</span><span class="w"> </span><span class="s">"line1</span><span class="se">\n</span><span class="s">line2</span><span class="se">\n</span><span class="s">line3</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Writing tests in this way also opens up a relatively straightforward
+debug path via the <strong>CMake: Set Debug target</strong> and <strong>CMake: Debug</strong>
+commands. If the first thing that happens when you write run your test
+is a crash, running the tests with the debugger turned on will
+automatically pause at the line of code that caused the crash. For more
+fine-tuned debugging, you can set breakpoints and step through code.</p>
+</section>
+<section id="summary">
+<h2>Summary<a class="headerlink" href="#summary" title="Permalink to this heading">#</a></h2>
+<p>This tutorial covered the basics of writing and testing a C++ library
+exposing an Arrow-based API implemented using the nanoarrow C library.</p>
+</section>
+</section>
+
+
+ </article>
+
+
+
+ <footer class="bd-footer-article">
+
+<div class="footer-article-items footer-article__inner">
+
+ <div class="footer-article-item"><!-- Previous / next buttons -->
+<div class="prev-next-area">
+</div></div>
+
+</div>
+
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+ <div class="sidebar-secondary-item">
+ <div class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-library">The library</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-development-environment">The development environment</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#the-interface">The interface</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrow-c-data-nanoarrow-interface-basics">Arrow C data/nanoarrow interface basics</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#building-the-library">Building the library</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#building-an-arrowarray">Building an ArrowArray</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#reading-an-arrowarray">Reading an ArrowArray</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#testing">Testing</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#summary">Summary</a></li>
+</ul>
+ </nav></div>
+
+ <div class="sidebar-secondary-item">
+
+ <div class="tocsection editthispage">
+ <a href="https://github.com/apache/arrow-nanoarrow/edit/main/docs/source/getting-started_generated.rst">
+ <i class="fa-solid fa-pencil"></i>
+
+
+
+ Edit on GitHub
+
+
+ </a>
+ </div>
+</div>
+
+ <div class="sidebar-secondary-item">
+ <div class="tocsection sourcelink">
+ <a href="_sources/getting-started_generated.rst.txt">
+ <i class="fa-solid fa-file-lines"></i> Show Source
+ </a>
+ </div>
+</div>
+
+</div></div>
+
+
+ </div>
+ <footer class="bd-footer-content">
+
+ </footer>
+
+ </main>
+ </div>
+ </div>
+
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="_static/scripts/bootstrap.js?digest=e353d410970836974a52"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52"></script>
+
+ <footer class="bd-footer">
+<div class="bd-footer__inner bd-page-width">
+
+ <div class="footer-items__start">
+
+ <div class="footer-item">
+ <p class="copyright">
+
+ © Copyright 2016-2023 Apache Software Foundation.
+ <br/>
+
+ </p>
+</div>
+
+ <div class="footer-item">
+ <p class="sphinx-version">
+ Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.0.1.
+ <br/>
+ </p>
+</div>
+
+ </div>
+
+
+ <div class="footer-items__end">
+
+ <div class="footer-item"><p class="theme-version">
+ Built with the <a href="https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html">PyData Sphinx Theme</a> 0.13.3.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/0.2.0/index.html b/0.2.0/index.html
new file mode 100644
index 0000000..201b862
--- /dev/null
+++ b/0.2.0/index.html
@@ -0,0 +1,593 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
+
+ <title>nanoarrow — nanoarrow documentation</title>
+
+
+
+ <script data-cfasync="false">
+ document.documentElement.dataset.mode = localStorage.getItem("mode") || "";
+ document.documentElement.dataset.theme = localStorage.getItem("theme") || "light";
+ </script>
+
+ <!-- Loaded before other Sphinx assets -->
+ <link href="_static/styles/theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=e353d410970836974a52" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=e353d410970836974a52" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.1.2/css/all.min.css?digest=e353d410970836974a52" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.1.2/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=e353d410970836974a52" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=e353d410970836974a52" />
+
+ <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+ <script src="_static/doctools.js"></script>
+ <script src="_static/sphinx_highlight.js"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'index';</script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="Getting started with nanoarrow" href="getting-started.html" />
+ <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ <meta name="docsearch:language" content="en"/>
+ </head>
+
+
+ <body data-bs-spy="scroll" data-bs-target=".bd-toc-nav" data-offset="180" data-bs-root-margin="0px 0px -60%" data-default-mode="">
+
+
+
+ <a class="skip-link" href="#main-content">Skip to main content</a>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__primary"
+ id="__primary"/>
+ <label class="overlay overlay-primary" for="__primary"></label>
+
+ <input type="checkbox"
+ class="sidebar-toggle"
+ name="__secondary"
+ id="__secondary"/>
+ <label class="overlay overlay-secondary" for="__secondary"></label>
+
+ <div class="search-button__wrapper">
+ <div class="search-button__overlay"></div>
+ <div class="search-button__search-container">
+<form class="bd-search d-flex align-items-center"
+ action="search.html"
+ method="get">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <input type="search"
+ class="form-control"
+ name="q"
+ id="search-input"
+ placeholder="Search the docs ..."
+ aria-label="Search the docs ..."
+ autocomplete="off"
+ autocorrect="off"
+ autocapitalize="off"
+ spellcheck="false"/>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd>K</kbd></span>
+</form></div>
+ </div>
+
+ <nav class="bd-header navbar navbar-expand-lg bd-navbar">
+<div class="bd-header__inner bd-page-width">
+ <label class="sidebar-toggle primary-toggle" for="__primary">
+ <span class="fa-solid fa-bars"></span>
+ </label>
+
+ <div class="navbar-header-items__start">
+
+ <div class="navbar-item">
+
+
+<a class="navbar-brand logo" href="#">
+
+
+
+
+
+ <p class="title logo__title">nanoarrow documentation</p>
+
+</a></div>
+
+ </div>
+
+
+ <div class="col-lg-9 navbar-header-items">
+
+ <div class="me-auto navbar-header-items__center">
+
+ <div class="navbar-item"><nav class="navbar-nav">
+ <p class="sidebar-header-items__title"
+ role="heading"
+ aria-level="1"
+ aria-label="Site Navigation">
+ Site Navigation
+ </p>
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started.html">
+ Getting Started
+ </a>
+ </li>
+
+
... 16274 lines suppressed ...