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 2024/02/02 13:31:12 UTC
(arrow-nanoarrow) branch asf-site updated: tweak latest behaviour
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
The following commit(s) were added to refs/heads/asf-site by this push:
new 62f582df tweak latest behaviour
62f582df is described below
commit 62f582df1b37387a9ae335bde69b9066545f71f0
Author: Dewey Dunnington <de...@voltrondata.com>
AuthorDate: Fri Feb 2 09:31:06 2024 -0400
tweak latest behaviour
---
0.3.0/.DS_Store | Bin 6148 -> 0 bytes
0.3.0/_static/.DS_Store | Bin 6148 -> 0 bytes
0.3.0/r/.DS_Store | Bin 6148 -> 0 bytes
latest/.buildinfo | 4 +
latest/.doctrees/environment.pickle | Bin 0 -> 4006165 bytes
latest/.doctrees/getting-started/cpp.doctree | Bin 0 -> 62084 bytes
latest/.doctrees/getting-started/index.doctree | Bin 0 -> 5635 bytes
latest/.doctrees/getting-started/python.doctree | Bin 0 -> 27435 bytes
latest/.doctrees/getting-started/r.doctree | Bin 0 -> 27684 bytes
latest/.doctrees/index.doctree | Bin 0 -> 17205 bytes
latest/.doctrees/reference/c.doctree | Bin 0 -> 1128567 bytes
latest/.doctrees/reference/cpp.doctree | Bin 0 -> 232123 bytes
latest/.doctrees/reference/device.doctree | Bin 0 -> 238870 bytes
latest/.doctrees/reference/index.doctree | Bin 0 -> 5851 bytes
latest/.doctrees/reference/ipc.doctree | Bin 0 -> 238667 bytes
latest/.doctrees/reference/python.doctree | Bin 0 -> 254502 bytes
latest/.doctrees/reference/r.doctree | Bin 0 -> 5588 bytes
latest/.doctrees/reference/testing.doctree | Bin 0 -> 7707 bytes
latest/.doctrees/roadmap.doctree | Bin 0 -> 21299 bytes
latest/_sources/getting-started/cpp.rst.txt | 542 +
latest/_sources/getting-started/index.rst.txt | 26 +
latest/_sources/getting-started/python.rst.txt | 294 +
latest/_sources/getting-started/r.rst.txt | 286 +
latest/_sources/index.rst.txt | 28 +
latest/_sources/reference/c.rst.txt | 78 +
latest/_sources/reference/cpp.rst.txt | 43 +
latest/_sources/reference/device.rst.txt | 41 +
latest/_sources/reference/index.rst.txt | 30 +
latest/_sources/reference/ipc.rst.txt | 33 +
latest/_sources/reference/python.rst.txt | 22 +
latest/_sources/reference/r.rst.txt | 21 +
latest/_sources/reference/testing.rst.txt | 27 +
latest/_sources/roadmap.rst.txt | 104 +
latest/_static/basic.css | 925 ++
latest/_static/doctools.js | 156 +
latest/_static/documentation_options.js | 13 +
latest/_static/file.png | Bin 0 -> 286 bytes
latest/_static/language_data.js | 199 +
latest/_static/minus.png | Bin 0 -> 90 bytes
latest/_static/plus.png | Bin 0 -> 90 bytes
latest/_static/pygments.css | 152 +
latest/_static/scripts/bootstrap.js | 3 +
latest/_static/scripts/bootstrap.js.LICENSE.txt | 5 +
latest/_static/scripts/bootstrap.js.map | 1 +
latest/_static/scripts/pydata-sphinx-theme.js | 2 +
latest/_static/scripts/pydata-sphinx-theme.js.map | 1 +
latest/_static/searchtools.js | 574 +
latest/_static/sphinx_highlight.js | 154 +
latest/_static/styles/bootstrap.css | 6 +
latest/_static/styles/bootstrap.css.map | 1 +
latest/_static/styles/pydata-sphinx-theme.css | 2 +
latest/_static/styles/pydata-sphinx-theme.css.map | 1 +
latest/_static/styles/theme.css | 2 +
.../_static/vendor/fontawesome/6.5.1/LICENSE.txt | 165 +
.../vendor/fontawesome/6.5.1/css/all.min.css | 5 +
.../_static/vendor/fontawesome/6.5.1/js/all.min.js | 2 +
.../fontawesome/6.5.1/js/all.min.js.LICENSE.txt | 5 +
.../fontawesome/6.5.1/webfonts/fa-brands-400.ttf | Bin 0 -> 207972 bytes
.../fontawesome/6.5.1/webfonts/fa-brands-400.woff2 | Bin 0 -> 117372 bytes
.../fontawesome/6.5.1/webfonts/fa-regular-400.ttf | Bin 0 -> 68004 bytes
.../6.5.1/webfonts/fa-regular-400.woff2 | Bin 0 -> 25452 bytes
.../fontawesome/6.5.1/webfonts/fa-solid-900.ttf | Bin 0 -> 419720 bytes
.../fontawesome/6.5.1/webfonts/fa-solid-900.woff2 | Bin 0 -> 156496 bytes
.../6.5.1/webfonts/fa-v4compatibility.ttf | Bin 0 -> 10832 bytes
.../6.5.1/webfonts/fa-v4compatibility.woff2 | Bin 0 -> 4792 bytes
latest/_static/webpack-macros.html | 31 +
latest/genindex.html | 1586 +++
latest/getting-started/cpp.html | 1033 ++
latest/getting-started/index.html | 540 +
latest/getting-started/python.html | 780 ++
latest/getting-started/r.html | 778 ++
latest/index.html | 600 +-
latest/objects.inv | Bin 0 -> 20989 bytes
latest/py-modindex.html | 445 +
latest/r/404.html | 90 +
latest/r/LICENSE.html | 145 +
latest/r/authors.html | 98 +
.../r/deps/bootstrap-5.3.1/bootstrap.bundle.min.js | 7 +
.../bootstrap-5.3.1/bootstrap.bundle.min.js.map | 1 +
latest/r/deps/bootstrap-5.3.1/bootstrap.min.css | 5 +
latest/r/deps/bootstrap-5.3.1/font.css | 124 +
.../1Ptxg8zYS_SKggPN4iEgvnHyvveLxVs9pbCIPrc.woff | Bin 0 -> 27828 bytes
.../1Ptxg8zYS_SKggPN4iEgvnHyvveLxVvaorCIPrc.woff | Bin 0 -> 27492 bytes
.../fonts/1adeadb2fe618c5ed46221f15e12b9c8.woff | Bin 0 -> 46088 bytes
.../bootstrap-5.3.1/fonts/4iCs6KVjbNBYlgo6ew.woff | Bin 0 -> 134032 bytes
.../fonts/4iCs6KVjbNBYlgoKfw7w.woff | Bin 0 -> 39832 bytes
.../fonts/4iCv6KVjbNBYlgoCxCvTtA.woff | Bin 0 -> 117140 bytes
.../fonts/4iCv6KVjbNBYlgoCxCvjsGyL.woff | Bin 0 -> 34452 bytes
.../fonts/6xK1dSBYKcSV-LCoeQqfX1RYOo3qPZ7nsDQ.woff | Bin 0 -> 17760 bytes
.../fonts/6xK1dSBYKcSV-LCoeQqfX1RYOo3qPa7j.woff | Bin 0 -> 49156 bytes
.../fonts/6xK3dSBYKcSV-LCoeQqfX1RYOo3aPA.woff | Bin 0 -> 74684 bytes
.../fonts/6xK3dSBYKcSV-LCoeQqfX1RYOo3qOK7j.woff | Bin 0 -> 18420 bytes
.../fonts/6xKydSBYKcSV-LCoeQqfX1RYOo3i54rAkw.woff | Bin 0 -> 74348 bytes
.../fonts/6xKydSBYKcSV-LCoeQqfX1RYOo3ig4vAkw.woff | Bin 0 -> 74332 bytes
.../6xKydSBYKcSV-LCoeQqfX1RYOo3ig4vwlxdo.woff | Bin 0 -> 18388 bytes
.../fonts/6xKydSBYKcSV-LCoeQqfX1RYOo3ik4zAkw.woff | Bin 0 -> 74148 bytes
.../6xKydSBYKcSV-LCoeQqfX1RYOo3ik4zwlxdo.woff | Bin 0 -> 18340 bytes
.../fonts/CSR54z1Qlv-GDxkbKVQ_dFsvWNRevw.woff | Bin 0 -> 16724 bytes
.../fonts/CSR54z1Qlv-GDxkbKVQ_dFsvaNA.woff | Bin 0 -> 29672 bytes
.../fonts/CSR64z1Qlv-GDxkbKVQ_TOQ.woff | Bin 0 -> 75128 bytes
.../fonts/CSR64z1Qlv-GDxkbKVQ_fOAKSw.woff | Bin 0 -> 16516 bytes
...YsKILxRpg3hIP6sJ7fM7PqPMcMnZFqUwX28DBKXhM0.woff | Bin 0 -> 55992 bytes
...YsKILxRpg3hIP6sJ7fM7PqPMcMnZFqUwX28DMyQhM0.woff | Bin 0 -> 56004 bytes
...ILxRpg3hIP6sJ7fM7PqlOPHYvDP_W9O7GQTTbI1rSg.woff | Bin 0 -> 47720 bytes
...ILxRpg3hIP6sJ7fM7PqlOPHYvDP_W9O7GQTTsoprSg.woff | Bin 0 -> 47924 bytes
.../JTUHjIg1_i6t8kCHKm4532VJOt5-QNFgpCtZ6Ew9.woff | Bin 0 -> 50580 bytes
.../JTUHjIg1_i6t8kCHKm4532VJOt5-QNFgpCtr6Ew9.woff | Bin 0 -> 50580 bytes
.../JTUHjIg1_i6t8kCHKm4532VJOt5-QNFgpCuM70w9.woff | Bin 0 -> 51108 bytes
.../fonts/KFOlCnqEu92Fr1MmEU9fBBc-.woff | Bin 0 -> 20544 bytes
.../fonts/KFOlCnqEu92Fr1MmEU9vAA.woff | Bin 0 -> 65756 bytes
.../fonts/KFOlCnqEu92Fr1MmSU5fBBc-.woff | Bin 0 -> 20416 bytes
.../fonts/KFOlCnqEu92Fr1MmSU5vAA.woff | Bin 0 -> 65164 bytes
.../fonts/KFOlCnqEu92Fr1MmWUlfBBc-.woff | Bin 0 -> 20408 bytes
.../fonts/KFOlCnqEu92Fr1MmWUlvAA.woff | Bin 0 -> 65556 bytes
.../bootstrap-5.3.1/fonts/KFOmCnqEu92Fr1Me5g.woff | Bin 0 -> 65456 bytes
.../fonts/KFOmCnqEu92Fr1Mu4mxM.woff | Bin 0 -> 20344 bytes
.../fonts/QGYpz_kZZAGCONcK2A4bGOj8mNhL.woff | Bin 0 -> 89776 bytes
.../fonts/S6u8w4BMUTPHjxsAXC-s.woff | Bin 0 -> 29864 bytes
.../bootstrap-5.3.1/fonts/S6u8w4BMUTPHjxswWA.woff | Bin 0 -> 35436 bytes
.../fonts/S6u9w4BMUTPHh6UVSwiPHw.woff | Bin 0 -> 28044 bytes
.../bootstrap-5.3.1/fonts/S6u9w4BMUTPHh6UVeww.woff | Bin 0 -> 33296 bytes
.../fonts/S6u9w4BMUTPHh7USSwiPHw.woff | Bin 0 -> 30016 bytes
.../bootstrap-5.3.1/fonts/S6u9w4BMUTPHh7USeww.woff | Bin 0 -> 35168 bytes
.../bootstrap-5.3.1/fonts/S6uyw4BMUTPHjx4wWA.woff | Bin 0 -> 28648 bytes
.../bootstrap-5.3.1/fonts/S6uyw4BMUTPHvxo.woff | Bin 0 -> 34020 bytes
...3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuFuYMZs.woff | Bin 0 -> 138900 bytes
...3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuI6fMZs.woff | Bin 0 -> 137508 bytes
...3iLTeHuS_fvQtMwCp50KnMw2boKoduKmMEVuLyfMZs.woff | Bin 0 -> 128192 bytes
.../fonts/XRXI3I6Li01BKofiOc5wtlZ2di8HDFwmRTA.woff | Bin 0 -> 53216 bytes
.../fonts/XRXI3I6Li01BKofiOc5wtlZ2di8HDGUmRTA.woff | Bin 0 -> 54196 bytes
.../fonts/XRXI3I6Li01BKofiOc5wtlZ2di8HDLshRTA.woff | Bin 0 -> 53856 bytes
.../fonts/a98f7a7574819ba83bec6279a2cecd95.woff | Bin 0 -> 45884 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk0ZjaVQ.woff | Bin 0 -> 72136 bytes
...UIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk5hkWVAexg.woff | Bin 0 -> 23636 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk5hkaVQ.woff | Bin 0 -> 74700 bytes
...UIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk8ZkWVAexg.woff | Bin 0 -> 23576 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk8ZkaVQ.woff | Bin 0 -> 74564 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk_RkaVQ.woff | Bin 0 -> 74940 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkxhjaVQ.woff | Bin 0 -> 74644 bytes
...UIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkyFjWVAexg.woff | Bin 0 -> 22964 bytes
...-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkyFjaVQ.woff | Bin 0 -> 71660 bytes
...-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsg-1x4gaVQ.woff | Bin 0 -> 22332 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsg-1y4k.woff | Bin 0 -> 68664 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsgH1y4k.woff | Bin 0 -> 70652 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgshZ1y4k.woff | Bin 0 -> 69392 bytes
...-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsiH0B4gaVQ.woff | Bin 0 -> 22940 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsiH0C4k.woff | Bin 0 -> 70524 bytes
...-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjZ0B4gaVQ.woff | Bin 0 -> 22908 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjZ0C4k.woff | Bin 0 -> 70792 bytes
...pBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjr0C4k.woff | Bin 0 -> 71144 bytes
.../fonts/q5uGsou0JOdh94bfvQlr.woff | Bin 0 -> 31584 bytes
latest/r/deps/data-deps.txt | 4 +
latest/r/deps/jquery-3.6.0/jquery-3.6.0.js | 10881 +++++++++++++++++++
latest/r/deps/jquery-3.6.0/jquery-3.6.0.min.js | 2 +
latest/r/deps/jquery-3.6.0/jquery-3.6.0.min.map | 1 +
latest/r/index.html | 323 +
latest/r/link.svg | 12 +
latest/r/news/index.html | 68 +
latest/r/pkgdown.js | 156 +
latest/r/pkgdown.yml | 6 +
latest/r/reference/Rplot001.png | Bin 0 -> 1011 bytes
latest/r/reference/array_stream_set_finalizer.html | 129 +
latest/r/reference/as_nanoarrow_array.html | 156 +
latest/r/reference/as_nanoarrow_array_stream.html | 172 +
latest/r/reference/as_nanoarrow_buffer.html | 114 +
latest/r/reference/as_nanoarrow_schema.html | 152 +
latest/r/reference/basic_array_stream.html | 117 +
latest/r/reference/convert_array.html | 160 +
latest/r/reference/convert_array_stream.html | 165 +
latest/r/reference/index.html | 166 +
latest/r/reference/infer_nanoarrow_ptype.html | 120 +
.../reference/infer_nanoarrow_ptype_extension.html | 120 +
latest/r/reference/na_type.html | 307 +
latest/r/reference/na_vctrs.html | 118 +
latest/r/reference/nanoarrow-package.html | 85 +
latest/r/reference/nanoarrow_array_init.html | 166 +
latest/r/reference/nanoarrow_buffer_init.html | 117 +
latest/r/reference/nanoarrow_extension_array.html | 119 +
latest/r/reference/nanoarrow_extension_spec.html | 123 +
latest/r/reference/nanoarrow_pointer_is_valid.html | 182 +
latest/r/reference/nanoarrow_version.html | 98 +
latest/r/search.json | 1 +
latest/r/sitemap.xml | 78 +
latest/reference/c.html | 2960 +++++
latest/reference/cpp.html | 1009 ++
latest/reference/device.html | 985 ++
latest/reference/index.html | 603 +
latest/reference/ipc.html | 1038 ++
latest/reference/python.html | 1676 +++
latest/reference/r.html | 520 +
latest/reference/testing.html | 544 +
latest/roadmap.html | 623 ++
latest/search.html | 451 +
latest/searchindex.js | 1 +
switcher.json | 4 +
195 files changed, 35047 insertions(+), 1 deletion(-)
diff --git a/0.3.0/.DS_Store b/0.3.0/.DS_Store
deleted file mode 100644
index d50b9244..00000000
Binary files a/0.3.0/.DS_Store and /dev/null differ
diff --git a/0.3.0/_static/.DS_Store b/0.3.0/_static/.DS_Store
deleted file mode 100644
index 2aa93a8e..00000000
Binary files a/0.3.0/_static/.DS_Store and /dev/null differ
diff --git a/0.3.0/r/.DS_Store b/0.3.0/r/.DS_Store
deleted file mode 100644
index b798ba5e..00000000
Binary files a/0.3.0/r/.DS_Store and /dev/null differ
diff --git a/latest/.buildinfo b/latest/.buildinfo
new file mode 100644
index 00000000..2534abcc
--- /dev/null
+++ b/latest/.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: eebe3f6919a2f3ba2cf8eb2fc2416a02
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/latest/.doctrees/environment.pickle b/latest/.doctrees/environment.pickle
new file mode 100644
index 00000000..82172ea6
Binary files /dev/null and b/latest/.doctrees/environment.pickle differ
diff --git a/latest/.doctrees/getting-started/cpp.doctree b/latest/.doctrees/getting-started/cpp.doctree
new file mode 100644
index 00000000..c24853f7
Binary files /dev/null and b/latest/.doctrees/getting-started/cpp.doctree differ
diff --git a/latest/.doctrees/getting-started/index.doctree b/latest/.doctrees/getting-started/index.doctree
new file mode 100644
index 00000000..6c27157b
Binary files /dev/null and b/latest/.doctrees/getting-started/index.doctree differ
diff --git a/latest/.doctrees/getting-started/python.doctree b/latest/.doctrees/getting-started/python.doctree
new file mode 100644
index 00000000..1e7edbe9
Binary files /dev/null and b/latest/.doctrees/getting-started/python.doctree differ
diff --git a/latest/.doctrees/getting-started/r.doctree b/latest/.doctrees/getting-started/r.doctree
new file mode 100644
index 00000000..c21bbd22
Binary files /dev/null and b/latest/.doctrees/getting-started/r.doctree differ
diff --git a/latest/.doctrees/index.doctree b/latest/.doctrees/index.doctree
new file mode 100644
index 00000000..95915ac3
Binary files /dev/null and b/latest/.doctrees/index.doctree differ
diff --git a/latest/.doctrees/reference/c.doctree b/latest/.doctrees/reference/c.doctree
new file mode 100644
index 00000000..c22d818d
Binary files /dev/null and b/latest/.doctrees/reference/c.doctree differ
diff --git a/latest/.doctrees/reference/cpp.doctree b/latest/.doctrees/reference/cpp.doctree
new file mode 100644
index 00000000..6e63d34f
Binary files /dev/null and b/latest/.doctrees/reference/cpp.doctree differ
diff --git a/latest/.doctrees/reference/device.doctree b/latest/.doctrees/reference/device.doctree
new file mode 100644
index 00000000..b63f2128
Binary files /dev/null and b/latest/.doctrees/reference/device.doctree differ
diff --git a/latest/.doctrees/reference/index.doctree b/latest/.doctrees/reference/index.doctree
new file mode 100644
index 00000000..6409883a
Binary files /dev/null and b/latest/.doctrees/reference/index.doctree differ
diff --git a/latest/.doctrees/reference/ipc.doctree b/latest/.doctrees/reference/ipc.doctree
new file mode 100644
index 00000000..35098a83
Binary files /dev/null and b/latest/.doctrees/reference/ipc.doctree differ
diff --git a/latest/.doctrees/reference/python.doctree b/latest/.doctrees/reference/python.doctree
new file mode 100644
index 00000000..9f1d7e79
Binary files /dev/null and b/latest/.doctrees/reference/python.doctree differ
diff --git a/latest/.doctrees/reference/r.doctree b/latest/.doctrees/reference/r.doctree
new file mode 100644
index 00000000..72280fd2
Binary files /dev/null and b/latest/.doctrees/reference/r.doctree differ
diff --git a/latest/.doctrees/reference/testing.doctree b/latest/.doctrees/reference/testing.doctree
new file mode 100644
index 00000000..af865045
Binary files /dev/null and b/latest/.doctrees/reference/testing.doctree differ
diff --git a/latest/.doctrees/roadmap.doctree b/latest/.doctrees/roadmap.doctree
new file mode 100644
index 00000000..f456cab6
Binary files /dev/null and b/latest/.doctrees/roadmap.doctree differ
diff --git a/latest/_sources/getting-started/cpp.rst.txt b/latest/_sources/getting-started/cpp.rst.txt
new file mode 100644
index 00000000..7c6501c8
--- /dev/null
+++ b/latest/_sources/getting-started/cpp.rst.txt
@@ -0,0 +1,542 @@
+.. 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 in C/C++
+=======================================
+
+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.
+
+Because 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 accommodate 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 happiness 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) {
+ ArrowSchemaRelease(&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.2.0/apache-arrow-nanoarrow-0.2.0.tar.gz
+ URL_HASH SHA512=38a100ae5c36a33aa330010eb27b051cff98671e9c82fff22b1692bb77ae61bd6dc2a52ac6922c6c8657bd4c79a059ab26e8413de8169eeed3c9b7fdb216c817)
+ 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 palette (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 is an
+``std::string``, which we’ll iterate over and add each detected line as
+its own element. First, we’ll define a function for the core logic of
+detecting 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 **CMake:
+Refresh Tests** and then **Test: Run All Tests** from the command
+palette to run them! You should see some output indicating 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/latest/_sources/getting-started/index.rst.txt b/latest/_sources/getting-started/index.rst.txt
new file mode 100644
index 00000000..3ca7140d
--- /dev/null
+++ b/latest/_sources/getting-started/index.rst.txt
@@ -0,0 +1,26 @@
+.. 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
+===============
+
+.. toctree::
+ :maxdepth: 2
+
+ C/C++ <cpp>
+ Python <python>
+ R <r>
diff --git a/latest/_sources/getting-started/python.rst.txt b/latest/_sources/getting-started/python.rst.txt
new file mode 100644
index 00000000..2b909e13
--- /dev/null
+++ b/latest/_sources/getting-started/python.rst.txt
@@ -0,0 +1,294 @@
+.. 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.
+ -->
+
+.. raw:: html
+
+ <!-- Render with jupyter nbconvert --to markdown README.ipynb -->
+
+nanoarrow for Python
+====================
+
+The nanoarrow Python package provides bindings to the nanoarrow C
+library. Like the nanoarrow C library, it provides tools to facilitate
+the use of the `Arrow C
+Data <https://arrow.apache.org/docs/format/CDataInterface.html>`__ and
+`Arrow C
+Stream <https://arrow.apache.org/docs/format/CStreamInterface.html>`__
+interfaces.
+
+Installation
+------------
+
+Python bindings for nanoarrow are not yet available on PyPI. You can
+install via URL (requires a C compiler):
+
+.. code:: bash
+
+ python -m pip install "git+https://github.com/apache/arrow-nanoarrow.git#egg=nanoarrow&subdirectory=python"
+
+If you can import the namespace, you’re good to go!
+
+.. code:: python
+
+ import nanoarrow as na
+
+Low-level C library bindings
+----------------------------
+
+The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the ``ArrowSchema`` which represents a data type of an
+array, the ``ArrowArray`` which represents the values of an array, and
+an ``ArrowArrayStream``, which represents zero or more ``ArrowArray``\ s
+with a common ``ArrowSchema``.
+
+Schemas
+~~~~~~~
+
+Use ``nanoarrow.c_schema()`` to convert an object to an ``ArrowSchema``
+and wrap it as a Python object. This works for any object implementing
+the `Arrow PyCapsule
+Interface <https://arrow.apache.org/docs/format/CDataInterface.html>`__
+(e.g., ``pyarrow.Schema``, ``pyarrow.DataType``, and ``pyarrow.Field``).
+
+.. code:: python
+
+ import pyarrow as pa
+ schema = na.c_schema(pa.decimal128(10, 3))
+ schema
+
+::
+
+ <nanoarrow.c_lib.CSchema decimal128(10, 3)>
+ - format: 'd:10,3'
+ - name: ''
+ - flags: 2
+ - metadata: NULL
+ - dictionary: NULL
+ - children[0]:
+
+You can extract the fields of a ``CSchema`` object one at a time or
+parse it into a view to extract deserialized parameters.
+
+.. code:: python
+
+ na.c_schema_view(schema)
+
+::
+
+ <nanoarrow.c_lib.CSchemaView>
+ - type: 'decimal128'
+ - storage_type: 'decimal128'
+ - decimal_bitwidth: 128
+ - decimal_precision: 10
+ - decimal_scale: 3
+
+Advanced users can allocate an empty ``CSchema`` and populate its
+contents by passing its ``._addr()`` to a schema-exporting function.
+
+.. code:: python
+
+ schema = na.allocate_c_schema()
+ pa.int32()._export_to_c(schema._addr())
+ schema
+
+::
+
+ <nanoarrow.c_lib.CSchema int32>
+ - format: 'i'
+ - name: ''
+ - flags: 2
+ - metadata: NULL
+ - dictionary: NULL
+ - children[0]:
+
+The ``CSchema`` object cleans up after itself: when the object is
+deleted, the underlying ``ArrowSchema`` is released.
+
+Arrays
+~~~~~~
+
+You can use ``nanoarrow.c_array()`` to convert an array-like object to
+an ``ArrowArray``, wrap it as a Python object, and attach a schema that
+can be used to interpret its contents. This works for any object
+implementing the `Arrow PyCapsule
+Interface <https://arrow.apache.org/docs/format/CDataInterface.html>`__
+(e.g., ``pyarrow.Array``, ``pyarrow.RecordBatch``).
+
+.. code:: python
+
+ array = na.c_array(pa.array(["one", "two", "three", None]))
+ array
+
+::
+
+ <nanoarrow.c_lib.CArray string>
+ - length: 4
+ - offset: 0
+ - null_count: 1
+ - buffers: (2939032895680, 2939032895616, 2939032895744)
+ - dictionary: NULL
+ - children[0]:
+
+You can extract the fields of a ``CArray`` one at a time or parse it
+into a view to extract deserialized content:
+
+.. code:: python
+
+ na.c_array_view(array)
+
+::
+
+ <nanoarrow.c_lib.CArrayView>
+ - storage_type: 'string'
+ - length: 4
+ - offset: 0
+ - null_count: 1
+ - buffers[3]:
+ - <bool validity[1 b] 11100000>
+ - <int32 data_offset[20 b] 0 3 6 11 11>
+ - <string data[11 b] b'onetwothree'>
+ - dictionary: NULL
+ - children[0]:
+
+Like the ``CSchema``, you can allocate an empty one and access its
+address with ``_addr()`` to pass to other array-exporting functions.
+
+.. code:: python
+
+ array = na.allocate_c_array()
+ pa.array([1, 2, 3])._export_to_c(array._addr(), array.schema._addr())
+ array.length
+
+::
+
+ 3
+
+Array streams
+~~~~~~~~~~~~~
+
+You can use ``nanoarrow.c_array_stream()`` to wrap an object
+representing a sequence of ``CArray``\ s with a common ``CSchema`` to an
+``ArrowArrayStream`` and wrap it as a Python object. This works for any
+object implementing the `Arrow PyCapsule
+Interface <https://arrow.apache.org/docs/format/CDataInterface.html>`__
+(e.g., ``pyarrow.RecordBatchReader``).
+
+.. code:: python
+
+ pa_array_child = pa.array([1, 2, 3], pa.int32())
+ pa_array = pa.record_batch([pa_array_child], names=["some_column"])
+ reader = pa.RecordBatchReader.from_batches(pa_array.schema, [pa_array])
+ array_stream = na.c_array_stream(reader)
+ array_stream
+
+::
+
+ <nanoarrow.c_lib.CArrayStream>
+ - get_schema(): <nanoarrow.c_lib.CSchema struct>
+ - format: '+s'
+ - name: ''
+ - flags: 0
+ - metadata: NULL
+ - dictionary: NULL
+ - children[1]:
+ 'some_column': <nanoarrow.c_lib.CSchema int32>
+ - format: 'i'
+ - name: 'some_column'
+ - flags: 2
+ - metadata: NULL
+ - dictionary: NULL
+ - children[0]:
+
+You can pull the next array from the stream using ``.get_next()`` or use
+it like an iterator. The ``.get_next()`` method will raise
+``StopIteration`` when there are no more arrays in the stream.
+
+.. code:: python
+
+ for array in array_stream:
+ print(array)
+
+::
+
+ <nanoarrow.c_lib.CArray struct>
+ - length: 3
+ - offset: 0
+ - null_count: 0
+ - buffers: (0,)
+ - dictionary: NULL
+ - children[1]:
+ 'some_column': <nanoarrow.c_lib.CArray int32>
+ - length: 3
+ - offset: 0
+ - null_count: 0
+ - buffers: (0, 2939033026688)
+ - dictionary: NULL
+ - children[0]:
+
+You can also get the address of a freshly-allocated stream to pass to a
+suitable exporting function:
+
+.. code:: python
+
+ array_stream = na.allocate_c_array_stream()
+ reader._export_to_c(array_stream._addr())
+ array_stream
+
+::
+
+ <nanoarrow.c_lib.CArrayStream>
+ - get_schema(): <nanoarrow.c_lib.CSchema struct>
+ - format: '+s'
+ - name: ''
+ - flags: 0
+ - metadata: NULL
+ - dictionary: NULL
+ - children[1]:
+ 'some_column': <nanoarrow.c_lib.CSchema int32>
+ - format: 'i'
+ - name: 'some_column'
+ - flags: 2
+ - metadata: NULL
+ - dictionary: NULL
+ - children[0]:
+
+Development
+-----------
+
+Python bindings for nanoarrow are managed with
+`setuptools <https://setuptools.pypa.io/en/latest/index.html>`__. This
+means you can build the project using:
+
+.. code:: shell
+
+ git clone https://github.com/apache/arrow-nanoarrow.git
+ cd arrow-nanoarrow/python
+ pip install -e .
+
+Tests use `pytest <https://docs.pytest.org/>`__:
+
+.. code:: shell
+
+ # Install dependencies
+ pip install -e .[test]
+
+ # Run tests
+ pytest -vvx
diff --git a/latest/_sources/getting-started/r.rst.txt b/latest/_sources/getting-started/r.rst.txt
new file mode 100644
index 00000000..f69f1e07
--- /dev/null
+++ b/latest/_sources/getting-started/r.rst.txt
@@ -0,0 +1,286 @@
+.. 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.
+ -->
+
+.. raw:: html
+
+ <!-- README.md is generated from README.Rmd. Please edit that file -->
+
+nanoarrow
+=========
+
+.. raw:: html
+
+ <!-- badges: start -->
+
+.. raw:: html
+
+ <!-- badges: end -->
+
+The goal of nanoarrow is to provide minimal useful bindings to the
+`Arrow C
+Data <https://arrow.apache.org/docs/format/CDataInterface.html>`__ and
+`Arrow C
+Stream <https://arrow.apache.org/docs/format/CStreamInterface.html>`__
+interfaces using the `nanoarrow C
+library <https://arrow.apache.org/nanoarrow>`__.
+
+Installation
+------------
+
+You can install the released version of nanoarrow from
+`CRAN <https://cran.r-project.org/>`__ with:
+
+.. code:: r
+
+ install.packages("nanoarrow")
+
+You can install the development version of nanoarrow from
+`GitHub <https://github.com/>`__ with:
+
+.. code:: r
+
+ # install.packages("remotes")
+ remotes::install_github("apache/arrow-nanoarrow/r")
+
+If you can load the package, you’re good to go!
+
+.. code:: r
+
+ library(nanoarrow)
+
+Example
+-------
+
+The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the ``ArrowSchema`` which represents a data type of an
+array, the ``ArrowArray`` which represents the values of an array, and
+an ``ArrowArrayStream``, which represents zero or more ``ArrowArray``\ s
+with a common ``ArrowSchema``. All three can be wrapped by R objects
+using the nanoarrow R package.
+
+Schemas
+~~~~~~~
+
+Use ``infer_nanoarrow_schema()`` to get the ArrowSchema object that
+corresponds to a given R vector type; use ``as_nanoarrow_schema()`` to
+convert an object from some other data type representation (e.g., an
+arrow R package ``DataType`` like ``arrow::int32()``); or use
+``na_XXX()`` functions to construct them.
+
+.. code:: r
+
+ infer_nanoarrow_schema(1:5)
+ #> <nanoarrow_schema int32>
+ #> $ format : chr "i"
+ #> $ name : chr ""
+ #> $ metadata : list()
+ #> $ flags : int 2
+ #> $ children : list()
+ #> $ dictionary: NULL
+ as_nanoarrow_schema(arrow::schema(col1 = arrow::float64()))
+ #> <nanoarrow_schema struct>
+ #> $ format : chr "+s"
+ #> $ name : chr ""
+ #> $ metadata : list()
+ #> $ flags : int 0
+ #> $ children :List of 1
+ #> ..$ col1:<nanoarrow_schema double>
+ #> .. ..$ format : chr "g"
+ #> .. ..$ name : chr "col1"
+ #> .. ..$ metadata : list()
+ #> .. ..$ flags : int 2
+ #> .. ..$ children : list()
+ #> .. ..$ dictionary: NULL
+ #> $ dictionary: NULL
+ na_int64()
+ #> <nanoarrow_schema int64>
+ #> $ format : chr "l"
+ #> $ name : chr ""
+ #> $ metadata : list()
+ #> $ flags : int 2
+ #> $ children : list()
+ #> $ dictionary: NULL
+
+Arrays
+~~~~~~
+
+Use ``as_nanoarrow_array()`` to convert an object to an ArrowArray
+object:
+
+.. code:: r
+
+ as_nanoarrow_array(1:5)
+ #> <nanoarrow_array int32[5]>
+ #> $ length : int 5
+ #> $ null_count: int 0
+ #> $ offset : int 0
+ #> $ buffers :List of 2
+ #> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+ #> $ dictionary: NULL
+ #> $ children : list()
+ as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+ #> <nanoarrow_array struct[2]>
+ #> $ length : int 2
+ #> $ null_count: int 0
+ #> $ offset : int 0
+ #> $ buffers :List of 1
+ #> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> $ children :List of 1
+ #> ..$ col1:<nanoarrow_array double[2]>
+ #> .. ..$ length : int 2
+ #> .. ..$ null_count: int 0
+ #> .. ..$ offset : int 0
+ #> .. ..$ buffers :List of 2
+ #> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+ #> .. ..$ dictionary: NULL
+ #> .. ..$ children : list()
+ #> $ dictionary: NULL
+
+You can use ``as.vector()`` or ``as.data.frame()`` to get the R
+representation of the object back:
+
+.. code:: r
+
+ array <- as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+ as.data.frame(array)
+ #> col1
+ #> 1 1.1
+ #> 2 2.2
+
+Even though at the C level the ArrowArray is distinct from the
+ArrowSchema, at the R level we attach a schema wherever possible. You
+can access the attached schema using ``infer_nanoarrow_schema()``:
+
+.. code:: r
+
+ infer_nanoarrow_schema(array)
+ #> <nanoarrow_schema struct>
+ #> $ format : chr "+s"
+ #> $ name : chr ""
+ #> $ metadata : list()
+ #> $ flags : int 0
+ #> $ children :List of 1
+ #> ..$ col1:<nanoarrow_schema double>
+ #> .. ..$ format : chr "g"
+ #> .. ..$ name : chr "col1"
+ #> .. ..$ metadata : list()
+ #> .. ..$ flags : int 2
+ #> .. ..$ children : list()
+ #> .. ..$ dictionary: NULL
+ #> $ dictionary: NULL
+
+Array Streams
+~~~~~~~~~~~~~
+
+The easiest way to create an ArrowArrayStream is from a list of arrays
+or objects that can be converted to an array using
+``as_nanoarrow_array()``:
+
+.. code:: r
+
+ stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+ )
+
+You can pull batches from the stream using the ``$get_next()`` method.
+The last batch will return ``NULL``.
+
+.. code:: r
+
+ stream$get_next()
+ #> <nanoarrow_array struct[2]>
+ #> $ length : int 2
+ #> $ null_count: int 0
+ #> $ offset : int 0
+ #> $ buffers :List of 1
+ #> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> $ children :List of 1
+ #> ..$ col1:<nanoarrow_array double[2]>
+ #> .. ..$ length : int 2
+ #> .. ..$ null_count: int 0
+ #> .. ..$ offset : int 0
+ #> .. ..$ buffers :List of 2
+ #> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+ #> .. ..$ dictionary: NULL
+ #> .. ..$ children : list()
+ #> $ dictionary: NULL
+ stream$get_next()
+ #> <nanoarrow_array struct[2]>
+ #> $ length : int 2
+ #> $ null_count: int 0
+ #> $ offset : int 0
+ #> $ buffers :List of 1
+ #> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> $ children :List of 1
+ #> ..$ col1:<nanoarrow_array double[2]>
+ #> .. ..$ length : int 2
+ #> .. ..$ null_count: int 0
+ #> .. ..$ offset : int 0
+ #> .. ..$ buffers :List of 2
+ #> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+ #> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `3.3 4.4`
+ #> .. ..$ dictionary: NULL
+ #> .. ..$ children : list()
+ #> $ dictionary: NULL
+ stream$get_next()
+ #> NULL
+
+You can pull all the batches into a ``data.frame()`` by calling
+``as.data.frame()`` or ``as.vector()``:
+
+.. code:: r
+
+ stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+ )
+
+ as.data.frame(stream)
+ #> col1
+ #> 1 1.1
+ #> 2 2.2
+ #> 3 3.3
+ #> 4 4.4
+
+After consuming a stream, you should call the release method as soon as
+you can. This lets the implementation of the stream release any
+resources (like open files) it may be holding in a more predictable way
+than waiting for the garbage collector to clean up the object.
+
+Integration with the arrow package
+----------------------------------
+
+The nanoarrow package implements ``as_nanoarrow_schema()``,
+``as_nanoarrow_array()``, and ``as_nanoarrow_array_stream()`` for most
+arrow package types. Similarly, it implements
+``arrow::as_arrow_array()``, ``arrow::as_record_batch()``,
+``arrow::as_arrow_table()``, ``arrow::as_record_batch_reader()``,
+``arrow::infer_type()``, ``arrow::as_data_type()``, and
+``arrow::as_schema()`` for nanoarrow objects such that you can pass
+equivalent nanoarrow objects into many arrow functions and vice versa.
diff --git a/latest/_sources/index.rst.txt b/latest/_sources/index.rst.txt
new file mode 100644
index 00000000..9076df54
--- /dev/null
+++ b/latest/_sources/index.rst.txt
@@ -0,0 +1,28 @@
+.. 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/index>
+ Roadmap <roadmap>
+ API Reference <reference/index>
diff --git a/latest/_sources/reference/c.rst.txt b/latest/_sources/reference/c.rst.txt
new file mode 100644
index 00000000..97d4d6ef
--- /dev/null
+++ b/latest/_sources/reference/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/latest/_sources/reference/cpp.rst.txt b/latest/_sources/reference/cpp.rst.txt
new file mode 100644
index 00000000..615262f4
--- /dev/null
+++ b/latest/_sources/reference/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/latest/_sources/reference/device.rst.txt b/latest/_sources/reference/device.rst.txt
new file mode 100644
index 00000000..8313d5fc
--- /dev/null
+++ b/latest/_sources/reference/device.rst.txt
@@ -0,0 +1,41 @@
+.. 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.
+
+Device Extension Reference
+==========================
+
+C API
+------------------------
+
+.. doxygengroup:: nanoarrow_device
+ :project: nanoarrow_device
+ :members:
+
+C++ Helpers
+------------------------
+
+.. doxygengroup:: nanoarrow_device_hpp-unique
+ :project: nanoarrow_device
+ :members:
+
+Arrow C Device Interface
+------------------------
+
+.. doxygengroup:: nanoarrow_device-arrow-cdata
+ :project: nanoarrow_device
+ :members:
+ :undoc-members:
diff --git a/latest/_sources/reference/index.rst.txt b/latest/_sources/reference/index.rst.txt
new file mode 100644
index 00000000..38c6c11d
--- /dev/null
+++ b/latest/_sources/reference/index.rst.txt
@@ -0,0 +1,30 @@
+.. 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.
+
+API Reference
+=============
+
+.. toctree::
+ :maxdepth: 2
+
+ R API Reference <r>
+ Python API Reference <python>
+ C API Reference <c>
+ C++ API Reference <cpp>
+ Testing API Reference <testing>
+ IPC Extension Reference <ipc>
+ Device Extension Reference <device>
diff --git a/latest/_sources/reference/ipc.rst.txt b/latest/_sources/reference/ipc.rst.txt
new file mode 100644
index 00000000..fb009c1a
--- /dev/null
+++ b/latest/_sources/reference/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/latest/_sources/reference/python.rst.txt b/latest/_sources/reference/python.rst.txt
new file mode 100644
index 00000000..94652478
--- /dev/null
+++ b/latest/_sources/reference/python.rst.txt
@@ -0,0 +1,22 @@
+.. 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.
+
+Python API reference
+====================
+
+.. automodule:: nanoarrow
+ :members:
diff --git a/latest/_sources/reference/r.rst.txt b/latest/_sources/reference/r.rst.txt
new file mode 100644
index 00000000..69becb16
--- /dev/null
+++ b/latest/_sources/reference/r.rst.txt
@@ -0,0 +1,21 @@
+.. 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.
+
+R API Reference
+==================
+
+See `R Documentation <../r/reference/index.html>`__.
diff --git a/latest/_sources/reference/testing.rst.txt b/latest/_sources/reference/testing.rst.txt
new file mode 100644
index 00000000..059099c4
--- /dev/null
+++ b/latest/_sources/reference/testing.rst.txt
@@ -0,0 +1,27 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Testing API Reference
+======================
+
+.. doxygengroup:: nanoarrow_testing
+
+Integration testing JSON
+------------------------
+
+.. doxygengroup:: nanoarrow_testing-json
+ :members:
diff --git a/latest/_sources/roadmap.rst.txt b/latest/_sources/roadmap.rst.txt
new file mode 100644
index 00000000..69330708
--- /dev/null
+++ b/latest/_sources/roadmap.rst.txt
@@ -0,0 +1,104 @@
+.. 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.
+ -->
+
+Roadmap
+=======
+
+Apache Arrow nanoarrow is a relatively new library and is under active
+development. Maintaining the balance between useful and minimal is
+difficult to do; however, there are a number of features that fit
+comforably within the scope of nanoarrow that have not yet been
+scheduled for implementation.
+
+C library
+---------
+
+- **Type coverage**: The C library currently provides support for all
+ types that are available via the Arrow C Data interface. When the
+ recently-added run-end encoded (REE) types and potentially
+ forthcoming string view/list view types are available via the Arrow C
+ Data interface, support should be added in nanoarrow as well.
+- **Array append**: The ``ArrowArrayAppend*()`` family of functions
+ provide a means by which to incrementally build arrays; however,
+ there is no built-in way to append an ``ArrowArrayView``, potentially
+ more efficiently appending multiple values at once. Among other
+ things, this would provide a route to an unoptimized filter/take
+ implementation.
+- **Remove Arrow C++ dependency for tests**: The C library and IPC
+ extension rely on Arrow C++ for some test code that was written early
+ in the library’s development. These tests are valuable to ensure
+ compatibility between nanoarrow and Arrow C++; however, including
+ them in the default test suite complicates release verification for
+ some users and prevents testing in environments where Arrow C++ does
+ not currently build (e.g., WASM, compilers without C++17 support).
+- **C++ integration**: The existing C++ integration is intentionally
+ minimal; however, there are likely improvements that could be made to
+ better integrate nanoarrow into existing C++ projects.
+- **Documentation**: As the C library and its user base evolves,
+ documentation needs to be refined and expanded to support the current
+ set of use cases.
+
+IPC extension
+-------------
+
+- **Write support**: The IPC extension currently provides support for
+ reading IPC streams but not writing them.
+- **Dictionary support**: The IPC extension does not currently support
+ reading dictionary messages an IPC stream.
+- **Compression**: The IPC extension does not currently support
+ compressed streams.
+
+Device extension
+----------------
+
+This entire extension is currently experimental and awaiting use-cases
+that will drive future development.
+
+R bindings
+----------
+
+- **Type support**: The R bindings currently do not provide support for
+ extension types and relies on Arrow C++ for some dictionary-encoded
+ types.
+- **ALTREP support**: A recent R release added enhanced ALTREP support
+ such that types that convert to ``list()`` can defer materialization
+ cost/allocation. Arrow sources that arrive in chunks (e.g., from a
+ ``Table`` or ``ChunkedArray``) currently can’t be converted via any
+ ALTREP mechanism and support could be added.
+- **IPC support**: The IPC reader is not currently exposed in the R
+ bindings.
+
+Python bindings
+---------------
+
+- **Packaging**: The Python bindings are currently unpublished (pypi or
+ conda) and are not included in release verification.
+- **Element conversion**: There is currently no mechanism to extract an
+ element of an ``ArrowArrayView`` as a Python object (e.g., an ``int``
+ or ``str``).
+- **numpy/Pandas conversion**: The Python bindings currently expose the
+ ``ArrowArrayView`` but do not provide a means by which to convert to
+ popular packages such as numpy or Pandas.
+- **Creating arrays**: The Python bindings do not currently provide a
+ means by which to create an ``ArrowArray`` from buffers or
+ incrementally.
+- **IPC support**: The IPC reader is not currently exposed in the
+ Python bindings.
diff --git a/latest/_static/basic.css b/latest/_static/basic.css
new file mode 100644
index 00000000..e760386b
--- /dev/null
+++ b/latest/_static/basic.css
@@ -0,0 +1,925 @@
+/*
+ * 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;
+}
+
+a:visited {
+ color: #551A8B;
+}
+
+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;
+}
+
+.sig dd {
+ margin-top: 0px;
+ margin-bottom: 0px;
+}
+
+.sig dl {
+ margin-top: 0px;
+ margin-bottom: 0px;
+}
+
+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;
+}
+
+.translated {
+ background-color: rgba(207, 255, 207, 0.2)
+}
+
+.untranslated {
+ background-color: rgba(255, 207, 207, 0.2)
+}
+
+/* -- 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/latest/_static/doctools.js b/latest/_static/doctools.js
new file mode 100644
index 00000000..d06a71d7
--- /dev/null
+++ b/latest/_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/latest/_static/documentation_options.js b/latest/_static/documentation_options.js
new file mode 100644
index 00000000..7e4c114f
--- /dev/null
+++ b/latest/_static/documentation_options.js
@@ -0,0 +1,13 @@
+const DOCUMENTATION_OPTIONS = {
+ VERSION: '',
+ LANGUAGE: 'en',
+ COLLAPSE_INDEX: false,
+ BUILDER: 'html',
+ FILE_SUFFIX: '.html',
+ LINK_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt',
+ NAVIGATION_WITH_KEYS: false,
+ SHOW_SEARCH_SUMMARY: true,
+ ENABLE_SEARCH_SHORTCUTS: true,
+};
\ No newline at end of file
diff --git a/latest/_static/file.png b/latest/_static/file.png
new file mode 100644
index 00000000..a858a410
Binary files /dev/null and b/latest/_static/file.png differ
diff --git a/latest/_static/language_data.js b/latest/_static/language_data.js
new file mode 100644
index 00000000..250f5665
--- /dev/null
+++ b/latest/_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/latest/_static/minus.png b/latest/_static/minus.png
new file mode 100644
index 00000000..d96755fd
Binary files /dev/null and b/latest/_static/minus.png differ
diff --git a/latest/_static/plus.png b/latest/_static/plus.png
new file mode 100644
index 00000000..7107cec9
Binary files /dev/null and b/latest/_static/plus.png differ
diff --git a/latest/_static/pygments.css b/latest/_static/pygments.css
new file mode 100644
index 00000000..997797f2
--- /dev/null
+++ b/latest/_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/latest/_static/scripts/bootstrap.js b/latest/_static/scripts/bootstrap.js
new file mode 100644
index 00000000..4e209b0e
--- /dev/null
+++ b/latest/_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:()=>E,afterRead:()=>v,afterWrite:()=>C,applyStyles:()=>$,arrow:()=>J,auto:()=>a,basePlacements:()=>l,beforeMain:()=>y,bef [...]
+//# sourceMappingURL=bootstrap.js.map
\ No newline at end of file
diff --git a/latest/_static/scripts/bootstrap.js.LICENSE.txt b/latest/_static/scripts/bootstrap.js.LICENSE.txt
new file mode 100644
index 00000000..10f979d0
--- /dev/null
+++ b/latest/_static/scripts/bootstrap.js.LICENSE.txt
@@ -0,0 +1,5 @@
+/*!
+ * Bootstrap v5.3.2 (https://getbootstrap.com/)
+ * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */
diff --git a/latest/_static/scripts/bootstrap.js.map b/latest/_static/scripts/bootstrap.js.map
new file mode 100644
index 00000000..64e212b1
--- /dev/null
+++ b/latest/_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,01BCLvD,IAAI,EAAM,MACNC,EAAS,SACTC,EAAQ,QACRC,EAAO,OACPC,EAAO,OA [...]
\ No newline at end of file
diff --git a/latest/_static/scripts/pydata-sphinx-theme.js b/latest/_static/scripts/pydata-sphinx-theme.js
new file mode 100644
index 00000000..25dee3ec
--- /dev/null
+++ b/latest/_static/scripts/pydata-sphinx-theme.js
@@ -0,0 +1,2 @@
+(()=>{"use strict";var e,t,n,r,o={803:(e,t,n)=>{n.d(t,{Gu:()=>r,qu:()=>o});const r=e=>"string"==typeof e&&/^[v\d]/.test(e)&&a.test(e),o=(e,t,n)=>{h(n);const r=((e,t)=>{const n=c(e),r=c(t),o=n.pop(),a=r.pop(),i=l(n,r);return 0!==i?i:o&&a?l(o.split("."),a.split(".")):o||a?o?-1:1:0})(e,t);return u[n].includes(r)},a=/^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i,c=e=>{if("string"!=typeof e)throw new [...]
+//# sourceMappingURL=pydata-sphinx-theme.js.map
\ No newline at end of file
diff --git a/latest/_static/scripts/pydata-sphinx-theme.js.map b/latest/_static/scripts/pydata-sphinx-theme.js.map
new file mode 100644
index 00000000..131caef3
--- /dev/null
+++ b/latest/_static/scripts/pydata-sphinx-theme.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"scripts/pydata-sphinx-theme.js","mappings":"uBAAIA,EACAC,EACAC,EACAC,E,4CCIG,MAiCMC,EAAYC,GAA+B,iBAAZA,GAAwB,SAASC,KAAKD,IAAYE,EAAOD,KAAKD,GAkB7FG,EAAU,CAACC,EAAIC,EAAIC,KAE5BC,EAAoBD,GAGpB,MAAME,EAxDqB,EAACJ,EAAIC,KAEhC,MAAMI,EAAKC,EAAiBN,GACtBO,EAAKD,EAAiBL,GAEtBO,EAAKH,EAAGI,MACRC,EAAKH,EAAGE,MAERE,EAAIC,EAAgBP,EAAIE,GAC9B,OAAU,IAANI,EACOA,EAEPH,GAAME,EACCE,EAAgBJ,EAAGK,MAAM,KAAMH,EAAGG,MAAM,MAE1CL,GAAME,EACJF,GAAM,EAAI,EAEd,CAAC,EAsCIM,CAAgBd,EAAIC,GAChC,OAAOc,EA [...]
\ No newline at end of file
diff --git a/latest/_static/searchtools.js b/latest/_static/searchtools.js
new file mode 100644
index 00000000..7918c3fa
--- /dev/null
+++ b/latest/_static/searchtools.js
@@ -0,0 +1,574 @@
+/*
+ * 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, highlightTerms) => {
+ const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
+ const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+ const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
+ const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
+ const contentRoot = document.documentElement.dataset.content_root;
+
+ 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 = contentRoot + dirname;
+ linkUrl = requestUrl;
+ } else {
+ // normal html builders
+ requestUrl = contentRoot + 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 + ")";
+ // highlight search terms in the description
+ if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js
+ highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
+ }
+ else if (showSearchSummary)
+ fetch(requestUrl)
+ .then((responseData) => responseData.text())
+ .then((data) => {
+ if (data)
+ listItem.appendChild(
+ Search.makeSearchSummary(data, searchTerms)
+ );
+ // highlight search terms in the summary
+ if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js
+ highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
+ });
+ 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,
+ highlightTerms,
+) => {
+ // 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, highlightTerms);
+ setTimeout(
+ () => _displayNextItem(results, resultCount, searchTerms, highlightTerms),
+ 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, highlightTerms);
+ },
+
+ /**
+ * 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/latest/_static/sphinx_highlight.js b/latest/_static/sphinx_highlight.js
new file mode 100644
index 00000000..8a96c69a
--- /dev/null
+++ b/latest/_static/sphinx_highlight.js
@@ -0,0 +1,154 @@
+/* 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)));
+ const rest = document.createTextNode(val.substr(pos + text.length));
+ parent.insertBefore(
+ span,
+ parent.insertBefore(
+ rest,
+ node.nextSibling
+ )
+ );
+ node.nodeValue = val.substr(0, pos);
+ /* There may be more occurrences of search term in this node. So call this
+ * function recursively on the remaining fragment.
+ */
+ _highlight(rest, addItems, text, className);
+
+ 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(() => {
+ /* Do not call highlightSearchWords() when we are on the search page.
+ * It will highlight words from the *previous* search query.
+ */
+ if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords();
+ SphinxHighlight.initEscapeListener();
+});
diff --git a/latest/_static/styles/bootstrap.css b/latest/_static/styles/bootstrap.css
new file mode 100644
index 00000000..82b03c0c
--- /dev/null
+++ b/latest/_static/styles/bootstrap.css
@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v5.3.2 (https://getbootstrap.com/)
+ * Copyright 2011-2023 The Bootstrap Authors
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */:root,[data-bs-theme=light]{--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;-- [...]
+/*# sourceMappingURL=bootstrap.css.map*/
\ No newline at end of file
diff --git a/latest/_static/styles/bootstrap.css.map b/latest/_static/styles/bootstrap.css.map
new file mode 100644
index 00000000..3929429a
--- /dev/null
+++ b/latest/_static/styles/bootstrap.css.map
@@ -0,0 +1 @@
+{"version":3,"file":"styles/bootstrap.css","mappings":"AAAA;;;;ECCE,CCDF,4BASI,qQAIA,sMAIA,iKAIA,sNAIA,iRAIA,iPAIA,iRAGF,2BACA,qBAMA,yMACA,mGACA,4EAOA,gDC2OI,wBALI,CDpOR,0BACA,0BAKA,wBACA,6BACA,kBACA,6BAEA,yBACA,8BAEA,wCACA,kCACA,0BACA,kCAEA,sCACA,iCACA,yBACA,iCAGA,2BAEA,wBACA,+BACA,+BAEA,8BACA,oCAMA,wBACA,6BACA,0BAGA,sBACA,wBACA,0BACA,+CAEA,4BACA,8BACA,6BACA,2BACA,4BACA,mDACA,8BAGA,8CACA,uDACA,gDACA,uDAIA,8BACA,6BACA,2CAIA,8BACA,qCACA,gCACA,uCEhHE,qBFyHA,wBACA,gCACA,qBACA,0BAEA,yBACA,oC [...]
\ No newline at end of file
diff --git a/latest/_static/styles/pydata-sphinx-theme.css b/latest/_static/styles/pydata-sphinx-theme.css
new file mode 100644
index 00000000..b81ac474
--- /dev/null
+++ b/latest/_static/styles/pydata-sphinx-theme.css
@@ -0,0 +1,2 @@
+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 [...]
+/*# sourceMappingURL=pydata-sphinx-theme.css.map*/
\ No newline at end of file
diff --git a/latest/_static/styles/pydata-sphinx-theme.css.map b/latest/_static/styles/pydata-sphinx-theme.css.map
new file mode 100644
index 00000000..cf7f6abd
--- /dev/null
+++ b/latest/_static/styles/pydata-sphinx-theme.css.map
@@ -0,0 +1 @@
+{"version":3,"file":"styles/pydata-sphinx-theme.css","mappings":"AAAA,KCAA,wBAOE,+DACA,+BCRF,yBAME,0BAGA,wBACA,2BACA,0BACA,2BACA,0BACA,6BAGA,+BAGA,sCACA,sCACA,qCACA,yCAGA,8BAGA,8BACA,2JAIA,mHAGA,0DAGA,6DACA,qECzCF,2BAME,4BAGA,2BACA,oCACA,kCACA,4BACA,yBACA,wBACA,0BACA,2BACA,6BACA,4BACA,sBACA,sBACA,qBACA,oBACA,sBACA,8BCxBF,kDAKE,uDACA,mEACA,mEACA,mEACA,kEACA,yDACA,qDACA,oDACA,mEACA,oDACA,mDCfF,qEAKE,oEACA,sEACA,0ECPF,mCACE,yDLQA,CKPA,KAGF,4CACE,CAGA,gCACA,CACA,YACA,uBANA,uCACA,gBACA,iBACA, [...]
\ No newline at end of file
diff --git a/latest/_static/styles/theme.css b/latest/_static/styles/theme.css
new file mode 100644
index 00000000..4519dd91
--- /dev/null
+++ b/latest/_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/latest/_static/vendor/fontawesome/6.5.1/LICENSE.txt b/latest/_static/vendor/fontawesome/6.5.1/LICENSE.txt
new file mode 100644
index 00000000..39e18e3d
--- /dev/null
+++ b/latest/_static/vendor/fontawesome/6.5.1/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) 2023 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 2023 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/latest/_static/vendor/fontawesome/6.5.1/css/all.min.css b/latest/_static/vendor/fontawesome/6.5.1/css/all.min.css
new file mode 100644
index 00000000..5f2038f0
--- /dev/null
+++ b/latest/_static/vendor/fontawesome/6.5.1/css/all.min.css
@@ -0,0 +1,5 @@
+/*!
+ * Font Awesome Free 6.5.1 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 2023 Fonticons, Inc.
+ */.fa{font-family:var(--fa-style-family,"Font Awesome 6 Free");font-weight:var(--fa-style,900)}.fa,.fa-brands,.fa-classic,.fa-regular,.fa-sharp,.fa-solid,.fab,.far,.fas{-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-classic,.fa-regular,.fa-solid,.far,.fas{font-family:Font Awesome\ 6 Free}.fa-brands,.fab{font-family:Font Awesome\ 6 Brands}.fa-1x{font-si [...]
\ No newline at end of file
diff --git a/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js b/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js
new file mode 100644
index 00000000..d981573a
--- /dev/null
+++ b/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js
@@ -0,0 +1,2 @@
+/*! For license information please see all.min.js.LICENSE.txt */
+!function(){"use strict";var c={},l={};try{"undefined"!=typeof window&&(c=window),"undefined"!=typeof document&&(l=document)}catch(c){}var s=void 0===(v=(c.navigator||{}).userAgent)?"":v,a=c,z=l;function e(c,l){var s,a=Object.keys(c);return Object.getOwnPropertySymbols&&(s=Object.getOwnPropertySymbols(c),l&&(s=s.filter((function(l){return Object.getOwnPropertyDescriptor(c,l).enumerable}))),a.push.apply(a,s)),a}function H(c){for(var l=1;l<arguments.length;l++){var s=null!=arguments[l]?arg [...]
\ No newline at end of file
diff --git a/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js.LICENSE.txt b/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js.LICENSE.txt
new file mode 100644
index 00000000..ef6dda40
--- /dev/null
+++ b/latest/_static/vendor/fontawesome/6.5.1/js/all.min.js.LICENSE.txt
@@ -0,0 +1,5 @@
+/*!
+ * Font Awesome Free 6.5.1 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 2023 Fonticons, Inc.
+ */
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.ttf b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.ttf
new file mode 100644
index 00000000..5efb1d4f
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.ttf differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2 b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2
new file mode 100644
index 00000000..36fbda7d
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2 differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.ttf b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.ttf
new file mode 100644
index 00000000..838b4e2c
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.ttf differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2 b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2
new file mode 100644
index 00000000..b6cabbac
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2 differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.ttf b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.ttf
new file mode 100644
index 00000000..ec24749d
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.ttf differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2 b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2
new file mode 100644
index 00000000..824d518e
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2 differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.ttf b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.ttf
new file mode 100644
index 00000000..b175aa8e
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.ttf differ
diff --git a/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.woff2 b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.woff2
new file mode 100644
index 00000000..e09b5a55
Binary files /dev/null and b/latest/_static/vendor/fontawesome/6.5.1/webfonts/fa-v4compatibility.woff2 differ
diff --git a/latest/_static/webpack-macros.html b/latest/_static/webpack-macros.html
new file mode 100644
index 00000000..243a8589
--- /dev/null
+++ b/latest/_static/webpack-macros.html
@@ -0,0 +1,31 @@
+<!--
+ 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.5.1/css/all.min.css', 1) }}?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2', 1) }}" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2', 1) }}" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="{{ pathto('_static/vendor/fontawesome/6.5.1/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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="{{ pathto('_static/styles/bootstrap.css', 1) }}?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="{{ pathto('_static/styles/pydata-sphinx-theme.css', 1) }}?digest=8d27b9dea8ad943066ae" 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=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="{{ pathto('_static/scripts/pydata-sphinx-theme.js', 1) }}?digest=8d27b9dea8ad943066ae" />
+ <script src="{{ pathto('_static/vendor/fontawesome/6.5.1/js/all.min.js', 1) }}?digest=8d27b9dea8ad943066ae"></script>
+{% endmacro %}
+
+{% macro body_post() %}
+ <!-- Scripts loaded after <body> so the DOM is not blocked -->
+ <script src="{{ pathto('_static/scripts/bootstrap.js', 1) }}?digest=8d27b9dea8ad943066ae"></script>
+<script src="{{ pathto('_static/scripts/pydata-sphinx-theme.js', 1) }}?digest=8d27b9dea8ad943066ae"></script>
+{% endmacro %}
\ No newline at end of file
diff --git a/latest/genindex.html b/latest/genindex.html
new file mode 100644
index 00000000..a9cb7892
--- /dev/null
+++ b/latest/genindex.html
@@ -0,0 +1,1586 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="./" >
+
+ <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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="_static/doctools.js?v=888ff710"></script>
+ <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'genindex';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started/index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+</div>
+
+ </header>
+
+
+ <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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started/index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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">
+
+
+<h1 id="index">Index</h1>
+
+<div class="genindex-jumpbox">
+ <a href="#_"><strong>_</strong></a>
+ | <a href="#A"><strong>A</strong></a>
+ | <a href="#B"><strong>B</strong></a>
+ | <a href="#C"><strong>C</strong></a>
+ | <a href="#D"><strong>D</strong></a>
+ | <a href="#F"><strong>F</strong></a>
+ | <a href="#I"><strong>I</strong></a>
+ | <a href="#L"><strong>L</strong></a>
+ | <a href="#M"><strong>M</strong></a>
+ | <a href="#N"><strong>N</strong></a>
+ | <a href="#P"><strong>P</strong></a>
+ | <a href="#R"><strong>R</strong></a>
+ | <a href="#S"><strong>S</strong></a>
+ | <a href="#T"><strong>T</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="reference/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="reference/python.html#nanoarrow.allocate_c_array">allocate_c_array() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.allocate_c_array_stream">allocate_c_array_stream() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.allocate_c_schema">allocate_c_schema() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/c.html#c.ARROW_C_DATA_INTERFACE">ARROW_C_DATA_INTERFACE (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_C_DEVICE_DATA_INTERFACE">ARROW_C_DEVICE_DATA_INTERFACE (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_C_DEVICE_STREAM_INTERFACE">ARROW_C_DEVICE_STREAM_INTERFACE (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.ARROW_C_STREAM_INTERFACE">ARROW_C_STREAM_INTERFACE (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_CPU">ARROW_DEVICE_CPU (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_CUDA">ARROW_DEVICE_CUDA (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_CUDA_HOST">ARROW_DEVICE_CUDA_HOST (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_CUDA_MANAGED">ARROW_DEVICE_CUDA_MANAGED (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_EXT_DEV">ARROW_DEVICE_EXT_DEV (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_HEXAGON">ARROW_DEVICE_HEXAGON (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_METAL">ARROW_DEVICE_METAL (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_ONEAPI">ARROW_DEVICE_ONEAPI (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_OPENCL">ARROW_DEVICE_OPENCL (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_ROCM">ARROW_DEVICE_ROCM (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_ROCM_HOST">ARROW_DEVICE_ROCM_HOST (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_VPI">ARROW_DEVICE_VPI (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_VULKAN">ARROW_DEVICE_VULKAN (C macro)</a>
+</li>
+ <li><a href="reference/device.html#c.ARROW_DEVICE_WEBGPU">ARROW_DEVICE_WEBGPU (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.ARROW_FLAG_DICTIONARY_ORDERED">ARROW_FLAG_DICTIONARY_ORDERED (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.ARROW_FLAG_MAP_KEYS_SORTED">ARROW_FLAG_MAP_KEYS_SORTED (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.ARROW_FLAG_NULLABLE">ARROW_FLAG_NULLABLE (C macro)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv410ArrowArray">ArrowArray (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray7buffersE">ArrowArray::buffers (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray8childrenE">ArrowArray::children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray10dictionaryE">ArrowArray::dictionary (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray6lengthE">ArrowArray::length (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray9n_buffersE">ArrowArray::n_buffers (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray10n_childrenE">ArrowArray::n_children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray10null_countE">ArrowArray::null_count (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray6offsetE">ArrowArray::offset (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray12private_dataE">ArrowArray::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowArray7releaseE">ArrowArray::release (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowArrayAllocateChildrenP10ArrowArray7int64_t">ArrowArrayAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowArrayAllocateDictionaryP10ArrowArray">ArrowArrayAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowArrayAppendBytesP10ArrowArray15ArrowBufferView">ArrowArrayAppendBytes (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowArrayAppendDecimalP10ArrowArrayPK12ArrowDecimal">ArrowArrayAppendDecimal (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowArrayAppendDoubleP10ArrowArrayd">ArrowArrayAppendDouble (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowArrayAppendEmptyP10ArrowArray7int64_t">ArrowArrayAppendEmpty (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowArrayAppendIntP10ArrowArray7int64_t">ArrowArrayAppendInt (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowArrayAppendIntervalP10ArrowArrayPK13ArrowInterval">ArrowArrayAppendInterval (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowArrayAppendNullP10ArrowArray7int64_t">ArrowArrayAppendNull (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowArrayAppendStringP10ArrowArray15ArrowStringView">ArrowArrayAppendString (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowArrayAppendUIntP10ArrowArray8uint64_t">ArrowArrayAppendUInt (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowArrayBufferP10ArrowArray7int64_t">ArrowArrayBuffer (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowArrayFinishBuildingP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowArrayFinishBuilding (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv431ArrowArrayFinishBuildingDefaultP10ArrowArrayP10ArrowError">ArrowArrayFinishBuildingDefault (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowArrayFinishElementP10ArrowArray">ArrowArrayFinishElement (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowArrayFinishUnionElementP10ArrowArray6int8_t">ArrowArrayFinishUnionElement (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowArrayInitFromArrayViewP10ArrowArrayPK14ArrowArrayViewP10ArrowError">ArrowArrayInitFromArrayView (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowArrayInitFromSchemaP10ArrowArrayPK11ArrowSchemaP10ArrowError">ArrowArrayInitFromSchema (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowArrayInitFromTypeP10ArrowArray9ArrowType">ArrowArrayInitFromType (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv414ArrowArrayMoveP10ArrowArrayP10ArrowArray">ArrowArrayMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowArrayReserveP10ArrowArray7int64_t">ArrowArrayReserve (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowArraySetBufferP10ArrowArray7int64_tP11ArrowBuffer">ArrowArraySetBuffer (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowArraySetValidityBitmapP10ArrowArrayP11ArrowBitmap">ArrowArraySetValidityBitmap (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowArrayShrinkToFitP10ArrowArray">ArrowArrayShrinkToFit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowArrayStartAppendingP10ArrowArray">ArrowArrayStartAppending (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowArrayStream">ArrowArrayStream (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N16ArrowArrayStream14get_last_errorE">ArrowArrayStream::get_last_error (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N16ArrowArrayStream8get_nextE">ArrowArrayStream::get_next (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N16ArrowArrayStream10get_schemaE">ArrowArrayStream::get_schema (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N16ArrowArrayStream12private_dataE">ArrowArrayStream::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N16ArrowArrayStream7releaseE">ArrowArrayStream::release (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowArrayStreamGetLastErrorP16ArrowArrayStream">ArrowArrayStreamGetLastError (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowArrayStreamGetNextP16ArrowArrayStreamP10ArrowArrayP10ArrowError">ArrowArrayStreamGetNext (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv425ArrowArrayStreamGetSchemaP16ArrowArrayStreamP11ArrowSchemaP10ArrowError">ArrowArrayStreamGetSchema (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowArrayStreamMoveP16ArrowArrayStreamP16ArrowArrayStream">ArrowArrayStreamMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowArrayValidityBitmapP10ArrowArray">ArrowArrayValidityBitmap (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv414ArrowArrayView">ArrowArrayView (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView5arrayE">ArrowArrayView::array (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView12buffer_viewsE">ArrowArrayView::buffer_views (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView8childrenE">ArrowArrayView::children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView10dictionaryE">ArrowArrayView::dictionary (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView6layoutE">ArrowArrayView::layout (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView6lengthE">ArrowArrayView::length (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView10n_childrenE">ArrowArrayView::n_children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView10null_countE">ArrowArrayView::null_count (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView6offsetE">ArrowArrayView::offset (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView12storage_typeE">ArrowArrayView::storage_type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N14ArrowArrayView17union_type_id_mapE">ArrowArrayView::union_type_id_map (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv430ArrowArrayViewAllocateChildrenP14ArrowArrayView7int64_t">ArrowArrayViewAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv432ArrowArrayViewAllocateDictionaryP14ArrowArrayView">ArrowArrayViewAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowArrayViewGetBytesUnsafePK14ArrowArrayView7int64_t">ArrowArrayViewGetBytesUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv430ArrowArrayViewGetDecimalUnsafePK14ArrowArrayView7int64_tP12ArrowDecimal">ArrowArrayViewGetDecimalUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv429ArrowArrayViewGetDoubleUnsafePK14ArrowArrayView7int64_t">ArrowArrayViewGetDoubleUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowArrayViewGetIntUnsafePK14ArrowArrayView7int64_t">ArrowArrayViewGetIntUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv429ArrowArrayViewGetStringUnsafePK14ArrowArrayView7int64_t">ArrowArrayViewGetStringUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowArrayViewGetUIntUnsafePK14ArrowArrayView7int64_t">ArrowArrayViewGetUIntUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowArrayViewInitFromSchemaP14ArrowArrayViewPK11ArrowSchemaP10ArrowError">ArrowArrayViewInitFromSchema (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowArrayViewInitFromTypeP14ArrowArrayView9ArrowType">ArrowArrayViewInitFromType (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowArrayViewIsNullPK14ArrowArrayView7int64_t">ArrowArrayViewIsNull (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowArrayViewMoveP14ArrowArrayViewP14ArrowArrayView">ArrowArrayViewMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowArrayViewResetP14ArrowArrayView">ArrowArrayViewReset (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowArrayViewSetArrayP14ArrowArrayViewPK10ArrowArrayP10ArrowError">ArrowArrayViewSetArray (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv429ArrowArrayViewSetArrayMinimalP14ArrowArrayViewPK10ArrowArrayP10ArrowError">ArrowArrayViewSetArrayMinimal (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowArrayViewSetLengthP14ArrowArrayView7int64_t">ArrowArrayViewSetLength (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv429ArrowArrayViewUnionChildIndexPK14ArrowArrayView7int64_t">ArrowArrayViewUnionChildIndex (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv430ArrowArrayViewUnionChildOffsetPK14ArrowArrayView7int64_t">ArrowArrayViewUnionChildOffset (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv425ArrowArrayViewUnionTypeIdPK14ArrowArrayView7int64_t">ArrowArrayViewUnionTypeId (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowArrayViewValidateP14ArrowArrayView20ArrowValidationLevelP10ArrowError">ArrowArrayViewValidate (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowBitClearP7uint8_t7int64_t">ArrowBitClear (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowBitCountSetPK7uint8_t7int64_t7int64_t">ArrowBitCountSet (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowBitGetPK7uint8_t7int64_t">ArrowBitGet (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowBitmap">ArrowBitmap (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBitmap6bufferE">ArrowBitmap::buffer (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBitmap9size_bitsE">ArrowBitmap::size_bits (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowBitmapAppendP11ArrowBitmap7uint8_t7int64_t">ArrowBitmapAppend (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv428ArrowBitmapAppendInt32UnsafeP11ArrowBitmapPK7int32_t7int64_t">ArrowBitmapAppendInt32Unsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowBitmapAppendInt8UnsafeP11ArrowBitmapPK6int8_t7int64_t">ArrowBitmapAppendInt8Unsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBitmapAppendUnsafeP11ArrowBitmap7uint8_t7int64_t">ArrowBitmapAppendUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBitmapInitP11ArrowBitmap">ArrowBitmapInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBitmapMoveP11ArrowBitmapP11ArrowBitmap">ArrowBitmapMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowBitmapReserveP11ArrowBitmap7int64_t">ArrowBitmapReserve (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowBitmapResetP11ArrowBitmap">ArrowBitmapReset (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowBitmapResizeP11ArrowBitmap7int64_tc">ArrowBitmapResize (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowBitSetP7uint8_t7int64_t">ArrowBitSet (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowBitSetToP7uint8_t7int64_t7uint8_t">ArrowBitSetTo (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv414ArrowBitsSetToP7uint8_t7int64_t7int64_t7uint8_t">ArrowBitsSetTo (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowBitsUnpackInt32PK7uint8_t7int64_t7int64_tP7int32_t">ArrowBitsUnpackInt32 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowBitsUnpackInt8PK7uint8_t7int64_t7int64_tP6int8_t">ArrowBitsUnpackInt8 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowBuffer">ArrowBuffer (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBuffer9allocatorE">ArrowBuffer::allocator (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBuffer14capacity_bytesE">ArrowBuffer::capacity_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBuffer4dataE">ArrowBuffer::data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowBuffer10size_bytesE">ArrowBuffer::size_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowBufferAllocator">ArrowBufferAllocator (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowBufferAllocator4freeE">ArrowBufferAllocator::free (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowBufferAllocator12private_dataE">ArrowBufferAllocator::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowBufferAllocator10reallocateE">ArrowBufferAllocator::reallocate (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowBufferAllocatorDefaultv">ArrowBufferAllocatorDefault (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowBufferAppendP11ArrowBufferPKv7int64_t">ArrowBufferAppend (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowBufferAppendBufferViewP11ArrowBuffer15ArrowBufferView">ArrowBufferAppendBufferView (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferAppendDoubleP11ArrowBufferd">ArrowBufferAppendDouble (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowBufferAppendFillP11ArrowBuffer7uint8_t7int64_t">ArrowBufferAppendFill (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferAppendFloatP11ArrowBufferf">ArrowBufferAppendFloat (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferAppendInt16P11ArrowBuffer7int16_t">ArrowBufferAppendInt16 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferAppendInt32P11ArrowBuffer7int32_t">ArrowBufferAppendInt32 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferAppendInt64P11ArrowBuffer7int64_t">ArrowBufferAppendInt64 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowBufferAppendInt8P11ArrowBuffer6int8_t">ArrowBufferAppendInt8 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowBufferAppendStringViewP11ArrowBuffer15ArrowStringView">ArrowBufferAppendStringView (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferAppendUInt16P11ArrowBuffer8uint16_t">ArrowBufferAppendUInt16 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferAppendUInt32P11ArrowBuffer8uint32_t">ArrowBufferAppendUInt32 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferAppendUInt64P11ArrowBuffer8uint64_t">ArrowBufferAppendUInt64 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferAppendUInt8P11ArrowBuffer7uint8_t">ArrowBufferAppendUInt8 (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferAppendUnsafeP11ArrowBufferPKv7int64_t">ArrowBufferAppendUnsafe (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowBufferDeallocatorPFvP20ArrowBufferAllocatorP7uint8_t7int64_tEPv">ArrowBufferDeallocator (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBufferInitP11ArrowBuffer">ArrowBufferInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBufferMoveP11ArrowBufferP11ArrowBuffer">ArrowBufferMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowBufferReserveP11ArrowBuffer7int64_t">ArrowBufferReserve (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowBufferResetP11ArrowBuffer">ArrowBufferReset (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowBufferResizeP11ArrowBuffer7int64_tc">ArrowBufferResize (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowBufferSetAllocatorP11ArrowBuffer20ArrowBufferAllocator">ArrowBufferSetAllocator (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBufferType">ArrowBufferType (C++ enum)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_DATAE">ArrowBufferType::NANOARROW_BUFFER_TYPE_DATA (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType33NANOARROW_BUFFER_TYPE_DATA_OFFSETE">ArrowBufferType::NANOARROW_BUFFER_TYPE_DATA_OFFSET (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType26NANOARROW_BUFFER_TYPE_NONEE">ArrowBufferType::NANOARROW_BUFFER_TYPE_NONE (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType29NANOARROW_BUFFER_TYPE_TYPE_IDE">ArrowBufferType::NANOARROW_BUFFER_TYPE_TYPE_ID (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType34NANOARROW_BUFFER_TYPE_UNION_OFFSETE">ArrowBufferType::NANOARROW_BUFFER_TYPE_UNION_OFFSET (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferType30NANOARROW_BUFFER_TYPE_VALIDITYE">ArrowBufferType::NANOARROW_BUFFER_TYPE_VALIDITY (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowBufferView">ArrowBufferView (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferView4dataE">ArrowBufferView::data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowBufferView10size_bytesE">ArrowBufferView::size_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowCharViewPKc">ArrowCharView (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv412ArrowDecimal">ArrowDecimal (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal15high_word_indexE">ArrowDecimal::high_word_index (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal14low_word_indexE">ArrowDecimal::low_word_index (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal7n_wordsE">ArrowDecimal::n_words (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal9precisionE">ArrowDecimal::precision (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal5scaleE">ArrowDecimal::scale (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N12ArrowDecimal5wordsE">ArrowDecimal::words (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv432ArrowDecimalAppendDigitsToBufferPK12ArrowDecimalP11ArrowBuffer">ArrowDecimalAppendDigitsToBuffer (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowDecimalGetBytesPK12ArrowDecimalP7uint8_t">ArrowDecimalGetBytes (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowDecimalInitP12ArrowDecimal7int32_t7int32_t7int32_t">ArrowDecimalInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowDecimalNegateP12ArrowDecimal">ArrowDecimalNegate (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowDecimalSetBytesP12ArrowDecimalPK7uint8_t">ArrowDecimalSetBytes (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowDecimalSetDigitsP12ArrowDecimal15ArrowStringView">ArrowDecimalSetDigits (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowDecimalSetIntP12ArrowDecimal7int64_t">ArrowDecimalSetInt (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv416ArrowDecimalSignPK12ArrowDecimal">ArrowDecimalSign (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv411ArrowDevice">ArrowDevice (C++ struct)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice10array_initE">ArrowDevice::array_init (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice10array_moveE">ArrowDevice::array_move (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice11buffer_copyE">ArrowDevice::buffer_copy (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice11buffer_initE">ArrowDevice::buffer_init (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice11buffer_moveE">ArrowDevice::buffer_move (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice9device_idE">ArrowDevice::device_id (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice11device_typeE">ArrowDevice::device_type (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice12private_dataE">ArrowDevice::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice7releaseE">ArrowDevice::release (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N11ArrowDevice17synchronize_eventE">ArrowDevice::synchronize_event (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv416ArrowDeviceArray">ArrowDeviceArray (C++ struct)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N16ArrowDeviceArray5arrayE">ArrowDeviceArray::array (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N16ArrowDeviceArray9device_idE">ArrowDeviceArray::device_id (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N16ArrowDeviceArray11device_typeE">ArrowDeviceArray::device_type (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N16ArrowDeviceArray8reservedE">ArrowDeviceArray::reserved (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N16ArrowDeviceArray10sync_eventE">ArrowDeviceArray::sync_event (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv420ArrowDeviceArrayInitP11ArrowDeviceP16ArrowDeviceArrayP10ArrowArray">ArrowDeviceArrayInit (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv420ArrowDeviceArrayMoveP16ArrowDeviceArrayP16ArrowDeviceArray">ArrowDeviceArrayMove (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv428ArrowDeviceArrayMoveToDeviceP16ArrowDeviceArrayP11ArrowDeviceP16ArrowDeviceArray">ArrowDeviceArrayMoveToDevice (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv422ArrowDeviceArrayStream">ArrowDeviceArrayStream (C++ struct)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream11device_typeE">ArrowDeviceArrayStream::device_type (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream14get_last_errorE">ArrowDeviceArrayStream::get_last_error (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream8get_nextE">ArrowDeviceArrayStream::get_next (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream10get_schemaE">ArrowDeviceArrayStream::get_schema (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream12private_dataE">ArrowDeviceArrayStream::private_data (C++ member)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/device.html#_CPPv4N22ArrowDeviceArrayStream7releaseE">ArrowDeviceArrayStream::release (C++ member)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv420ArrowDeviceArrayView">ArrowDeviceArrayView (C++ struct)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv424ArrowDeviceArrayViewCopyP20ArrowDeviceArrayViewP11ArrowDeviceP16ArrowDeviceArray">ArrowDeviceArrayViewCopy (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv424ArrowDeviceArrayViewInitP20ArrowDeviceArrayView">ArrowDeviceArrayViewInit (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv425ArrowDeviceArrayViewResetP20ArrowDeviceArrayView">ArrowDeviceArrayViewReset (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv428ArrowDeviceArrayViewSetArrayP20ArrowDeviceArrayViewP16ArrowDeviceArrayP10ArrowError">ArrowDeviceArrayViewSetArray (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv435ArrowDeviceArrayViewSetArrayMinimalP20ArrowDeviceArrayViewP16ArrowDeviceArrayP10ArrowError">ArrowDeviceArrayViewSetArrayMinimal (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv431ArrowDeviceBasicArrayStreamInitP22ArrowDeviceArrayStreamP16ArrowArrayStreamP11ArrowDevice">ArrowDeviceBasicArrayStreamInit (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv421ArrowDeviceBufferCopyP11ArrowDevice15ArrowBufferViewP11ArrowDevice15ArrowBufferView">ArrowDeviceBufferCopy (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv421ArrowDeviceBufferInitP11ArrowDevice15ArrowBufferViewP11ArrowDeviceP11ArrowBuffer">ArrowDeviceBufferInit (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv421ArrowDeviceBufferMoveP11ArrowDeviceP11ArrowBufferP11ArrowDeviceP11ArrowBuffer">ArrowDeviceBufferMove (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv423ArrowDeviceCheckRuntimeP10ArrowError">ArrowDeviceCheckRuntime (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv414ArrowDeviceCpuv">ArrowDeviceCpu (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv418ArrowDeviceInitCpuP11ArrowDevice">ArrowDeviceInitCpu (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv418ArrowDeviceResolve15ArrowDeviceType7int64_t">ArrowDeviceResolve (C++ function)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv415ArrowDeviceType">ArrowDeviceType (C++ type)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv410ArrowError">ArrowError (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N10ArrowError7messageE">ArrowError::message (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv414ArrowErrorCode">ArrowErrorCode (C++ type)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv414ArrowErrorInitP10ArrowError">ArrowErrorInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowErrorMessageP10ArrowError">ArrowErrorMessage (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowErrorSetP10ArrowErrorPKcz">ArrowErrorSet (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowErrorSetStringP10ArrowErrorPKc">ArrowErrorSetString (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv49ArrowFreePv">ArrowFree (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowInterval">ArrowInterval (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowInterval4daysE">ArrowInterval::days (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowInterval6monthsE">ArrowInterval::months (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowInterval2msE">ArrowInterval::ms (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowInterval2nsE">ArrowInterval::ns (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowInterval4typeE">ArrowInterval::type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv417ArrowIntervalInitP13ArrowInterval9ArrowType">ArrowIntervalInit (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv429ArrowIpcArrayStreamReaderInitP16ArrowArrayStreamP19ArrowIpcInputStreamP32ArrowIpcArrayStreamReaderOptions">ArrowIpcArrayStreamReaderInit (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv432ArrowIpcArrayStreamReaderOptions">ArrowIpcArrayStreamReaderOptions (C++ struct)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N32ArrowIpcArrayStreamReaderOptions11field_indexE">ArrowIpcArrayStreamReaderOptions::field_index (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N32ArrowIpcArrayStreamReaderOptions18use_shared_buffersE">ArrowIpcArrayStreamReaderOptions::use_shared_buffers (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv420ArrowIpcCheckRuntimeP10ArrowError">ArrowIpcCheckRuntime (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv423ArrowIpcCompressionType">ArrowIpcCompressionType (C++ enum)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcCompressionType40NANOARROW_IPC_COMPRESSION_TYPE_LZ4_FRAMEE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_LZ4_FRAME (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcCompressionType35NANOARROW_IPC_COMPRESSION_TYPE_NONEE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_NONE (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcCompressionType35NANOARROW_IPC_COMPRESSION_TYPE_ZSTDE">ArrowIpcCompressionType::NANOARROW_IPC_COMPRESSION_TYPE_ZSTD (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv415ArrowIpcDecoder">ArrowIpcDecoder (C++ struct)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder15body_size_bytesE">ArrowIpcDecoder::body_size_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder5codecE">ArrowIpcDecoder::codec (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder10endiannessE">ArrowIpcDecoder::endianness (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder13feature_flagsE">ArrowIpcDecoder::feature_flags (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder17header_size_bytesE">ArrowIpcDecoder::header_size_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder12message_typeE">ArrowIpcDecoder::message_type (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder16metadata_versionE">ArrowIpcDecoder::metadata_version (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N15ArrowIpcDecoder12private_dataE">ArrowIpcDecoder::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv426ArrowIpcDecoderDecodeArrayP15ArrowIpcDecoder15ArrowBufferView7int64_tP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowIpcDecoderDecodeArray (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv436ArrowIpcDecoderDecodeArrayFromSharedP15ArrowIpcDecoderP20ArrowIpcSharedBuffer7int64_tP10ArrowArray20ArrowValidationLevelP10ArrowError">ArrowIpcDecoderDecodeArrayFromShared (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv430ArrowIpcDecoderDecodeArrayViewP15ArrowIpcDecoder15ArrowBufferView7int64_tPP14ArrowArrayViewP10ArrowError">ArrowIpcDecoderDecodeArrayView (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv427ArrowIpcDecoderDecodeHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderDecodeHeader (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv427ArrowIpcDecoderDecodeSchemaP15ArrowIpcDecoderP11ArrowSchemaP10ArrowError">ArrowIpcDecoderDecodeSchema (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv419ArrowIpcDecoderInitP15ArrowIpcDecoder">ArrowIpcDecoderInit (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv425ArrowIpcDecoderPeekHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderPeekHeader (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv420ArrowIpcDecoderResetP15ArrowIpcDecoder">ArrowIpcDecoderReset (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv428ArrowIpcDecoderSetEndiannessP15ArrowIpcDecoder18ArrowIpcEndianness">ArrowIpcDecoderSetEndianness (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv424ArrowIpcDecoderSetSchemaP15ArrowIpcDecoderP11ArrowSchemaP10ArrowError">ArrowIpcDecoderSetSchema (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv427ArrowIpcDecoderVerifyHeaderP15ArrowIpcDecoder15ArrowBufferViewP10ArrowError">ArrowIpcDecoderVerifyHeader (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv418ArrowIpcEndianness">ArrowIpcEndianness (C++ enum)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N18ArrowIpcEndianness28NANOARROW_IPC_ENDIANNESS_BIGE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_BIG (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N18ArrowIpcEndianness31NANOARROW_IPC_ENDIANNESS_LITTLEE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_LITTLE (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N18ArrowIpcEndianness38NANOARROW_IPC_ENDIANNESS_UNINITIALIZEDE">ArrowIpcEndianness::NANOARROW_IPC_ENDIANNESS_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv419ArrowIpcInputStream">ArrowIpcInputStream (C++ struct)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcInputStream12private_dataE">ArrowIpcInputStream::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcInputStream4readE">ArrowIpcInputStream::read (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcInputStream7releaseE">ArrowIpcInputStream::release (C++ member)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv429ArrowIpcInputStreamInitBufferP19ArrowIpcInputStreamP11ArrowBuffer">ArrowIpcInputStreamInitBuffer (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv427ArrowIpcInputStreamInitFileP19ArrowIpcInputStreamPvi">ArrowIpcInputStreamInitFile (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv423ArrowIpcInputStreamMoveP19ArrowIpcInputStreamP19ArrowIpcInputStream">ArrowIpcInputStreamMove (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv419ArrowIpcMessageType">ArrowIpcMessageType (C++ enum)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType43NANOARROW_IPC_MESSAGE_TYPE_DICTIONARY_BATCHE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_DICTIONARY_BATCH (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType39NANOARROW_IPC_MESSAGE_TYPE_RECORD_BATCHE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_RECORD_BATCH (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType33NANOARROW_IPC_MESSAGE_TYPE_SCHEMAE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_SCHEMA (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType40NANOARROW_IPC_MESSAGE_TYPE_SPARSE_TENSORE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_SPARSE_TENSOR (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType33NANOARROW_IPC_MESSAGE_TYPE_TENSORE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_TENSOR (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N19ArrowIpcMessageType40NANOARROW_IPC_MESSAGE_TYPE_UNINITIALIZEDE">ArrowIpcMessageType::NANOARROW_IPC_MESSAGE_TYPE_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv423ArrowIpcMetadataVersion">ArrowIpcMetadataVersion (C++ enum)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V1E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V1 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V2E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V2 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V3E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V3 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V4E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V4 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv4N23ArrowIpcMetadataVersion33NANOARROW_IPC_METADATA_VERSION_V5E">ArrowIpcMetadataVersion::NANOARROW_IPC_METADATA_VERSION_V5 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv420ArrowIpcSharedBuffer">ArrowIpcSharedBuffer (C++ struct)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv424ArrowIpcSharedBufferInitP20ArrowIpcSharedBufferP11ArrowBuffer">ArrowIpcSharedBufferInit (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv432ArrowIpcSharedBufferIsThreadSafev">ArrowIpcSharedBufferIsThreadSafe (C++ function)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv425ArrowIpcSharedBufferResetP20ArrowIpcSharedBuffer">ArrowIpcSharedBufferReset (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowLayout">ArrowLayout (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowLayout16buffer_data_typeE">ArrowLayout::buffer_data_type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowLayout11buffer_typeE">ArrowLayout::buffer_type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowLayout19child_size_elementsE">ArrowLayout::child_size_elements (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowLayout17element_size_bitsE">ArrowLayout::element_size_bits (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowLayoutInitP11ArrowLayout9ArrowType">ArrowLayoutInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowMalloc7int64_t">ArrowMalloc (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowMetadataBuilderAppendP11ArrowBuffer15ArrowStringView15ArrowStringView">ArrowMetadataBuilderAppend (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowMetadataBuilderInitP11ArrowBufferPKc">ArrowMetadataBuilderInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowMetadataBuilderRemoveP11ArrowBuffer15ArrowStringView">ArrowMetadataBuilderRemove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowMetadataBuilderSetP11ArrowBuffer15ArrowStringView15ArrowStringView">ArrowMetadataBuilderSet (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowMetadataGetValuePKc15ArrowStringViewP15ArrowStringView">ArrowMetadataGetValue (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowMetadataHasKeyPKc15ArrowStringView">ArrowMetadataHasKey (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowMetadataReader">ArrowMetadataReader (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N19ArrowMetadataReader8metadataE">ArrowMetadataReader::metadata (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N19ArrowMetadataReader6offsetE">ArrowMetadataReader::offset (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N19ArrowMetadataReader14remaining_keysE">ArrowMetadataReader::remaining_keys (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowMetadataReaderInitP19ArrowMetadataReaderPKc">ArrowMetadataReaderInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowMetadataReaderReadP19ArrowMetadataReaderP15ArrowStringViewP15ArrowStringView">ArrowMetadataReaderRead (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowMetadataSizeOfPKc">ArrowMetadataSizeOf (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv421ArrowNanoarrowVersionv">ArrowNanoarrowVersion (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowNanoarrowVersionIntv">ArrowNanoarrowVersionInt (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv412ArrowReallocPv7int64_t">ArrowRealloc (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv411ArrowSchema">ArrowSchema (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema8childrenE">ArrowSchema::children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema10dictionaryE">ArrowSchema::dictionary (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema5flagsE">ArrowSchema::flags (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema6formatE">ArrowSchema::format (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema8metadataE">ArrowSchema::metadata (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema10n_childrenE">ArrowSchema::n_children (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema4nameE">ArrowSchema::name (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema12private_dataE">ArrowSchema::private_data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N11ArrowSchema7releaseE">ArrowSchema::release (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowSchemaAllocateChildrenP11ArrowSchema7int64_t">ArrowSchemaAllocateChildren (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv429ArrowSchemaAllocateDictionaryP11ArrowSchema">ArrowSchemaAllocateDictionary (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowSchemaDeepCopyPK11ArrowSchemaP11ArrowSchema">ArrowSchemaDeepCopy (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowSchemaInitP11ArrowSchema">ArrowSchemaInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowSchemaInitFromTypeP11ArrowSchema9ArrowType">ArrowSchemaInitFromType (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowSchemaMoveP11ArrowSchemaP11ArrowSchema">ArrowSchemaMove (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowSchemaReleaseP11ArrowSchema">ArrowSchemaRelease (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowSchemaSetFormatP11ArrowSchemaPKc">ArrowSchemaSetFormat (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv422ArrowSchemaSetMetadataP11ArrowSchemaPKc">ArrowSchemaSetMetadata (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowSchemaSetNameP11ArrowSchemaPKc">ArrowSchemaSetName (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv418ArrowSchemaSetTypeP11ArrowSchema9ArrowType">ArrowSchemaSetType (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv426ArrowSchemaSetTypeDateTimeP11ArrowSchema9ArrowType13ArrowTimeUnitPKc">ArrowSchemaSetTypeDateTime (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv425ArrowSchemaSetTypeDecimalP11ArrowSchema9ArrowType7int32_t7int32_t">ArrowSchemaSetTypeDecimal (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv427ArrowSchemaSetTypeFixedSizeP11ArrowSchema9ArrowType7int32_t">ArrowSchemaSetTypeFixedSize (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv424ArrowSchemaSetTypeStructP11ArrowSchema7int64_t">ArrowSchemaSetTypeStruct (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv423ArrowSchemaSetTypeUnionP11ArrowSchema9ArrowType7int64_t">ArrowSchemaSetTypeUnion (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowSchemaToStringPK11ArrowSchemaPc7int64_tc">ArrowSchemaToString (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowSchemaView">ArrowSchemaView (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView16decimal_bitwidthE">ArrowSchemaView::decimal_bitwidth (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView17decimal_precisionE">ArrowSchemaView::decimal_precision (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView13decimal_scaleE">ArrowSchemaView::decimal_scale (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView18extension_metadataE">ArrowSchemaView::extension_metadata (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView14extension_nameE">ArrowSchemaView::extension_name (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView10fixed_sizeE">ArrowSchemaView::fixed_size (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView6layoutE">ArrowSchemaView::layout (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView6schemaE">ArrowSchemaView::schema (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView12storage_typeE">ArrowSchemaView::storage_type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView9time_unitE">ArrowSchemaView::time_unit (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView8timezoneE">ArrowSchemaView::timezone (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView4typeE">ArrowSchemaView::type (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowSchemaView14union_type_idsE">ArrowSchemaView::union_type_ids (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowSchemaViewInitP15ArrowSchemaViewPK11ArrowSchemaP10ArrowError">ArrowSchemaViewInit (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowStringView">ArrowStringView (C++ struct)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowStringView4dataE">ArrowStringView::data (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N15ArrowStringView10size_bytesE">ArrowStringView::size_bytes (C++ member)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv413ArrowTimeUnit">ArrowTimeUnit (C++ enum)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MICROE">ArrowTimeUnit::NANOARROW_TIME_UNIT_MICRO (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowTimeUnit25NANOARROW_TIME_UNIT_MILLIE">ArrowTimeUnit::NANOARROW_TIME_UNIT_MILLI (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowTimeUnit24NANOARROW_TIME_UNIT_NANOE">ArrowTimeUnit::NANOARROW_TIME_UNIT_NANO (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N13ArrowTimeUnit26NANOARROW_TIME_UNIT_SECONDE">ArrowTimeUnit::NANOARROW_TIME_UNIT_SECOND (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv419ArrowTimeUnitString13ArrowTimeUnit">ArrowTimeUnitString (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv49ArrowType">ArrowType (C++ enum)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_BINARYE">ArrowType::NANOARROW_TYPE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_BOOLE">ArrowType::NANOARROW_TYPE_BOOL (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DATE32E">ArrowType::NANOARROW_TYPE_DATE32 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DATE64E">ArrowType::NANOARROW_TYPE_DATE64 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL128E">ArrowType::NANOARROW_TYPE_DECIMAL128 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DECIMAL256E">ArrowType::NANOARROW_TYPE_DECIMAL256 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType26NANOARROW_TYPE_DENSE_UNIONE">ArrowType::NANOARROW_TYPE_DENSE_UNION (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_DICTIONARYE">ArrowType::NANOARROW_TYPE_DICTIONARY (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_DOUBLEE">ArrowType::NANOARROW_TYPE_DOUBLE (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType23NANOARROW_TYPE_DURATIONE">ArrowType::NANOARROW_TYPE_DURATION (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType24NANOARROW_TYPE_EXTENSIONE">ArrowType::NANOARROW_TYPE_EXTENSION (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType32NANOARROW_TYPE_FIXED_SIZE_BINARYE">ArrowType::NANOARROW_TYPE_FIXED_SIZE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType30NANOARROW_TYPE_FIXED_SIZE_LISTE">ArrowType::NANOARROW_TYPE_FIXED_SIZE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_FLOATE">ArrowType::NANOARROW_TYPE_FLOAT (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_HALF_FLOATE">ArrowType::NANOARROW_TYPE_HALF_FLOAT (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT16E">ArrowType::NANOARROW_TYPE_INT16 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT32E">ArrowType::NANOARROW_TYPE_INT32 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_INT64E">ArrowType::NANOARROW_TYPE_INT64 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_INT8E">ArrowType::NANOARROW_TYPE_INT8 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType32NANOARROW_TYPE_INTERVAL_DAY_TIMEE">ArrowType::NANOARROW_TYPE_INTERVAL_DAY_TIME (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType38NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANOE">ArrowType::NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType30NANOARROW_TYPE_INTERVAL_MONTHSE">ArrowType::NANOARROW_TYPE_INTERVAL_MONTHS (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_BINARYE">ArrowType::NANOARROW_TYPE_LARGE_BINARY (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType25NANOARROW_TYPE_LARGE_LISTE">ArrowType::NANOARROW_TYPE_LARGE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_LARGE_STRINGE">ArrowType::NANOARROW_TYPE_LARGE_STRING (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType19NANOARROW_TYPE_LISTE">ArrowType::NANOARROW_TYPE_LIST (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType18NANOARROW_TYPE_MAPE">ArrowType::NANOARROW_TYPE_MAP (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType17NANOARROW_TYPE_NAE">ArrowType::NANOARROW_TYPE_NA (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType27NANOARROW_TYPE_SPARSE_UNIONE">ArrowType::NANOARROW_TYPE_SPARSE_UNION (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_STRINGE">ArrowType::NANOARROW_TYPE_STRING (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_STRUCTE">ArrowType::NANOARROW_TYPE_STRUCT (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_TIME32E">ArrowType::NANOARROW_TYPE_TIME32 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_TIME64E">ArrowType::NANOARROW_TYPE_TIME64 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType24NANOARROW_TYPE_TIMESTAMPE">ArrowType::NANOARROW_TYPE_TIMESTAMP (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT16E">ArrowType::NANOARROW_TYPE_UINT16 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT32E">ArrowType::NANOARROW_TYPE_UINT32 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType21NANOARROW_TYPE_UINT64E">ArrowType::NANOARROW_TYPE_UINT64 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType20NANOARROW_TYPE_UINT8E">ArrowType::NANOARROW_TYPE_UINT8 (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N9ArrowType28NANOARROW_TYPE_UNINITIALIZEDE">ArrowType::NANOARROW_TYPE_UNINITIALIZED (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv415ArrowTypeString9ArrowType">ArrowTypeString (C++ function)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv420ArrowValidationLevel">ArrowValidationLevel (C++ enum)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_DEFAULTE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_DEFAULT (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_FULLE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_FULL (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowValidationLevel34NANOARROW_VALIDATION_LEVEL_MINIMALE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_MINIMAL (C++ enumerator)</a>
+</li>
+ <li><a href="reference/c.html#_CPPv4N20ArrowValidationLevel31NANOARROW_VALIDATION_LEVEL_NONEE">ArrowValidationLevel::NANOARROW_VALIDATION_LEVEL_NONE (C++ enumerator)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="B">B</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.binary">binary() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.bool">bool() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.byte_width">byte_width (Schema property)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="C">C</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.c_array">c_array() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.c_array_stream">c_array_stream() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.c_array_view">c_array_view() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.c_schema">c_schema() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.c_schema_view">c_schema_view() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.c_version">c_version() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.TimeUnit.create">create() (TimeUnit static method)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="D">D</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.date32">date32() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.date64">date64() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.decimal128">decimal128() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.decimal256">decimal256() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.duration">duration() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="F">F</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.Schema.field">field() (Schema method)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.fields">fields (Schema property)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.fixed_size_binary">fixed_size_binary() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.float16">float16() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.float32">float32() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.float64">float64() (in module nanoarrow)</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="reference/cpp.html#_CPPv4I0E12init_pointervP1T">init_pointer (C++ function)</a>, <a href="reference/cpp.html#_CPPv4IE12init_pointervP10ArrowArray">[1]</a>, <a href="reference/cpp.html#_CPPv4IE12init_pointervP11ArrowBitmap">[2]</a>, <a href="reference/cpp.html#_CPPv4IE12init_pointervP11ArrowBuffer">[3]</a>, <a href="reference/cpp.html#_CPPv4IE12init_pointervP11ArrowSchema">[4]</a>, <a href="reference/cpp.html#_CPPv4IE12init_pointervP14ArrowArrayView">[5]</a>, <a href="r [...]
+</li>
+ <li><a href="reference/python.html#nanoarrow.int16">int16() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.int32">int32() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.int64">int64() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.int8">int8() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.interval_day_time">interval_day_time() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.interval_month_day_nano">interval_month_day_nano() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.interval_months">interval_months() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="L">L</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.large_binary">large_binary() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.large_string">large_string() (in module nanoarrow)</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>
+ module
+
+ <ul>
+ <li><a href="reference/python.html#module-nanoarrow">nanoarrow</a>
+</li>
+ </ul></li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/cpp.html#_CPPv4I0E12move_pointervP1TP1T">move_pointer (C++ function)</a>, <a href="reference/cpp.html#_CPPv4IE12move_pointervP10ArrowArrayP10ArrowArray">[1]</a>, <a href="reference/cpp.html#_CPPv4IE12move_pointervP11ArrowBitmapP11ArrowBitmap">[2]</a>, <a href="reference/cpp.html#_CPPv4IE12move_pointervP11ArrowBufferP11ArrowBuffer">[3]</a>, <a href="reference/cpp.html#_CPPv4IE12move_pointervP11ArrowSchemaP11ArrowSchema">[4]</a>, <a href="reference/cpp.html#_CP [...]
+</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="reference/python.html#nanoarrow.Schema.n_fields">n_fields (Schema property)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.name">name (Schema property)</a>
+</li>
+ <li>
+ nanoarrow
+
+ <ul>
+ <li><a href="reference/python.html#module-nanoarrow">module</a>
+</li>
+ </ul></li>
+ <li><a href="reference/cpp.html#_CPPv4I0EN9nanoarrow18ArrayStreamFactoryE">nanoarrow::ArrayStreamFactory (C++ class)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow18ArrayStreamFactory15InitArrayStreamEP1TP16ArrowArrayStream">nanoarrow::ArrayStreamFactory::InitArrayStream (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow16EmptyArrayStreamE">nanoarrow::EmptyArrayStream (C++ class)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow16EmptyArrayStream16EmptyArrayStreamEP11ArrowSchema">nanoarrow::EmptyArrayStream::EmptyArrayStream (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow16EmptyArrayStream10MakeUniqueEP11ArrowSchema">nanoarrow::EmptyArrayStream::MakeUnique (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow16EmptyArrayStream13ToArrayStreamEP16ArrowArrayStream">nanoarrow::EmptyArrayStream::ToArrayStream (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow9ExceptionE">nanoarrow::Exception (C++ class)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4I0EN9nanoarrow8internal6UniqueE">nanoarrow::internal::Unique (C++ class)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique3getEv">nanoarrow::internal::Unique::get (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique4moveEP1T">nanoarrow::internal::Unique::move (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6UniqueptEv">nanoarrow::internal::Unique::operator-> (C++ function)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique5resetEP1T">nanoarrow::internal::Unique::reset (C++ function)</a>, <a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique5resetEv">[1]</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueEP1T">nanoarrow::internal::Unique::Unique (C++ function)</a>, <a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueERR6Unique">[1]</a>, <a href="reference/cpp.html#_CPPv4N9nanoarrow8internal6Unique6UniqueEv">[2]</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStreamE">nanoarrow::VectorArrayStream (C++ class)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaNSt6vectorI11UniqueArrayEE">nanoarrow::VectorArrayStream::MakeUnique (C++ function)</a>, <a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStream10MakeUniqueEP11ArrowSchemaP10ArrowArray">[1]</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStream13ToArrayStreamEP16ArrowArrayStream">nanoarrow::VectorArrayStream::ToArrayStream (C++ function)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStream17VectorArrayStreamEP11ArrowSchemaNSt6vectorI11UniqueArrayEE">nanoarrow::VectorArrayStream::VectorArrayStream (C++ function)</a>, <a href="reference/cpp.html#_CPPv4N9nanoarrow17VectorArrayStream17VectorArrayStreamEP11ArrowSchemaP10ArrowArray">[1]</a>
+</li>
+ <li><a href="reference/c.html#c.NANOARROW_FLAG_ALL_SUPPORTED">NANOARROW_FLAG_ALL_SUPPORTED (C macro)</a>
+</li>
+ <li><a href="reference/ipc.html#c.NANOARROW_IPC_FEATURE_COMPRESSED_BODY">NANOARROW_IPC_FEATURE_COMPRESSED_BODY (C macro)</a>
+</li>
+ <li><a href="reference/ipc.html#c.NANOARROW_IPC_FEATURE_DICTIONARY_REPLACEMENT">NANOARROW_IPC_FEATURE_DICTIONARY_REPLACEMENT (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.NANOARROW_MAX_FIXED_BUFFERS">NANOARROW_MAX_FIXED_BUFFERS (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.NANOARROW_OK">NANOARROW_OK (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.NANOARROW_RETURN_NOT_OK">NANOARROW_RETURN_NOT_OK (C macro)</a>
+</li>
+ <li><a href="reference/c.html#c.NANOARROW_RETURN_NOT_OK_WITH_ERROR">NANOARROW_RETURN_NOT_OK_WITH_ERROR (C macro)</a>
+</li>
+ <li><a href="reference/cpp.html#c.NANOARROW_THROW_NOT_OK">NANOARROW_THROW_NOT_OK (C macro)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.null">null() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.nullable">nullable (Schema property)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="P">P</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.Schema.precision">precision (Schema property)</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="reference/cpp.html#_CPPv4I0E15release_pointervP1T">release_pointer (C++ function)</a>, <a href="reference/cpp.html#_CPPv4IE15release_pointervP10ArrowArray">[1]</a>, <a href="reference/cpp.html#_CPPv4IE15release_pointervP11ArrowBitmap">[2]</a>, <a href="reference/cpp.html#_CPPv4IE15release_pointervP11ArrowBuffer">[3]</a>, <a href="reference/cpp.html#_CPPv4IE15release_pointervP11ArrowSchema">[4]</a>, <a href="reference/cpp.html#_CPPv4IE15release_pointervP14ArrowArrayView [...]
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="S">S</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.Schema.scale">scale (Schema property)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema">Schema (class in nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.schema">schema() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.string">string() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.struct">struct() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+<h2 id="T">T</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.time32">time32() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.time64">time64() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.timestamp">timestamp() (in module nanoarrow)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/python.html#nanoarrow.TimeUnit">TimeUnit (class in nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.timezone">timezone (Schema property)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Type">Type (class in nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.type">type (Schema property)</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="reference/python.html#nanoarrow.uint16">uint16() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.uint32">uint32() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.uint64">uint64() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.uint8">uint8() (in module nanoarrow)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv411UniqueArray">UniqueArray (C++ type)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv417UniqueArrayStream">UniqueArrayStream (C++ type)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv415UniqueArrayView">UniqueArrayView (C++ type)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv412UniqueBitmap">UniqueBitmap (C++ type)</a>
+</li>
+ </ul></td>
+ <td style="width: 33%; vertical-align: top;"><ul>
+ <li><a href="reference/cpp.html#_CPPv412UniqueBuffer">UniqueBuffer (C++ type)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv413UniqueDecoder">UniqueDecoder (C++ type)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv412UniqueDevice">UniqueDevice (C++ type)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv417UniqueDeviceArray">UniqueDeviceArray (C++ type)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv423UniqueDeviceArrayStream">UniqueDeviceArrayStream (C++ type)</a>
+</li>
+ <li><a href="reference/device.html#_CPPv421UniqueDeviceArrayView">UniqueDeviceArrayView (C++ type)</a>
+</li>
+ <li><a href="reference/ipc.html#_CPPv417UniqueInputStream">UniqueInputStream (C++ type)</a>
+</li>
+ <li><a href="reference/cpp.html#_CPPv412UniqueSchema">UniqueSchema (C++ type)</a>
+</li>
+ <li><a href="reference/python.html#nanoarrow.Schema.unit">unit (Schema property)</a>
+</li>
+ </ul></td>
+</tr></table>
+
+
+
+ </article>
+
+
+
+
+
+ <footer class="prev-next-footer">
+
+<div class="prev-next-area">
+</div>
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"></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=8d27b9dea8ad943066ae"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/getting-started/cpp.html b/latest/getting-started/cpp.html
new file mode 100644
index 00000000..610b08ce
--- /dev/null
+++ b/latest/getting-started/cpp.html
@@ -0,0 +1,1033 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="../" >
+
+ <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 in C/C++ — 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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="../_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="../_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="../_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="../_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="../_static/doctools.js?v=888ff710"></script>
+ <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started/cpp';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.html" />
+ <link rel="next" title="nanoarrow for Python" href="python.html" />
+ <link rel="prev" title="Getting Started" 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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary" tabindex="0">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </header>
+
+
+ <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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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 class="sidebar-primary-item">
+<nav class="bd-docs-nav bd-links"
+ aria-label="Section Navigation">
+ <p class="bd-links__title" role="heading" aria-level="1">Section Navigation</p>
+ <div class="bd-toc-item navbar-nav"><ul class="current nav bd-sidenav">
+<li class="toctree-l1 current active"><a class="current reference internal" href="#">C/C++</a></li>
+<li class="toctree-l1"><a class="reference internal" href="python.html">Python</a></li>
+<li class="toctree-l1"><a class="reference internal" href="r.html">R</a></li>
+</ul>
+</div>
+</nav></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="Breadcrumb">
+ <ul class="bd-breadcrumbs">
+
+ <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"><a href="index.html" class="nav-link">Getting Started</a></li>
+
+ <li class="breadcrumb-item active" aria-current="page">Getting...</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article">
+
+ <!---
+ 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-in-c-c">
+<h1>Getting started with nanoarrow in C/C++<a class="headerlink" href="#getting-started-with-nanoarrow-in-c-c" title="Link 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>Because 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="Link 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="Link 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="Link 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="Link 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 accommodate 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 happiness 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">ArrowSchemaRelease</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="Link 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.2.0/apache-arrow-nanoarrow-0.2.0.tar.gz</span>
+<span class="w"> </span><span class="s">URL_HASH</span><span class="w"> </span><span class="s">SHA512=38a100ae5c36a33aa330010eb27b051cff98671e9c82fff22b1692bb77ae61bd6dc2a52ac6922c6c8657bd4c79a059ab26e8413de8169eeed3c9b7fdb216c817</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 palette (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="Link to this heading">#</a></h2>
+<p>The input for our <code class="docutils literal notranslate"><span class="pre">linesplitter_read()</span></code> function is 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, we’ll define a function for the core logic of
+detecting 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="Link 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="Link 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>CMake:
+Refresh Tests</strong> and then <strong>Test: Run All Tests</strong> from the command
+palette to run them! You should see some output indicating 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="Link 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="prev-next-footer">
+
+<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">Getting Started</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="python.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">nanoarrow for Python</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div>
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+
+ <div class="sidebar-secondary-item">
+<div
+ id="pst-page-navigation-heading-2"
+ class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc" aria-labelledby="pst-page-navigation-heading-2">
+ <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/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/getting-started/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=8d27b9dea8ad943066ae"></script>
+<script src="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/getting-started/index.html b/latest/getting-started/index.html
new file mode 100644
index 00000000..ddb17bad
--- /dev/null
+++ b/latest/getting-started/index.html
@@ -0,0 +1,540 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="../" >
+
+ <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 — 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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="../_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="../_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="../_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="../_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="../_static/doctools.js?v=888ff710"></script>
+ <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started/index';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </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 in C/C++" href="cpp.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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <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="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary" tabindex="0">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </header>
+
+
+ <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">
+ <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="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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 class="sidebar-primary-item">
+<nav class="bd-docs-nav bd-links"
+ aria-label="Section Navigation">
+ <p class="bd-links__title" role="heading" aria-level="1">Section Navigation</p>
+ <div class="bd-toc-item navbar-nav"><ul class="nav bd-sidenav">
+<li class="toctree-l1"><a class="reference internal" href="cpp.html">C/C++</a></li>
+<li class="toctree-l1"><a class="reference internal" href="python.html">Python</a></li>
+<li class="toctree-l1"><a class="reference internal" href="r.html">R</a></li>
+</ul>
+</div>
+</nav></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="Breadcrumb">
+ <ul class="bd-breadcrumbs">
+
+ <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</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article">
+
+ <section id="getting-started">
+<h1>Getting Started<a class="headerlink" href="#getting-started" title="Link to this heading">#</a></h1>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="cpp.html">C/C++</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#the-library">The library</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#the-development-environment">The development environment</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#the-interface">The interface</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#arrow-c-data-nanoarrow-interface-basics">Arrow C data/nanoarrow interface basics</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#building-the-library">Building the library</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#building-an-arrowarray">Building an ArrowArray</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#reading-an-arrowarray">Reading an ArrowArray</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#testing">Testing</a></li>
+<li class="toctree-l2"><a class="reference internal" href="cpp.html#summary">Summary</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="python.html">Python</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="python.html#installation">Installation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="python.html#low-level-c-library-bindings">Low-level C library bindings</a></li>
+<li class="toctree-l2"><a class="reference internal" href="python.html#development">Development</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="r.html">R</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="r.html#installation">Installation</a></li>
+<li class="toctree-l2"><a class="reference internal" href="r.html#example">Example</a></li>
+<li class="toctree-l2"><a class="reference internal" href="r.html#integration-with-the-arrow-package">Integration with the arrow package</a></li>
+</ul>
+</li>
+</ul>
+</div>
+</section>
+
+
+ </article>
+
+
+
+
+
+ <footer class="prev-next-footer">
+
+<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="cpp.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">Getting started with nanoarrow in C/C++</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</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="tocsection editthispage">
+ <a href="https://github.com/apache/arrow-nanoarrow/edit/main/docs/source/getting-started/index.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/index.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=8d27b9dea8ad943066ae"></script>
+<script src="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/getting-started/python.html b/latest/getting-started/python.html
new file mode 100644
index 00000000..d6e02a75
--- /dev/null
+++ b/latest/getting-started/python.html
@@ -0,0 +1,780 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="../" >
+
+ <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 for Python — 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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="../_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="../_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="../_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="../_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="../_static/doctools.js?v=888ff710"></script>
+ <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started/python';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.html" />
+ <link rel="next" title="nanoarrow" href="r.html" />
+ <link rel="prev" title="Getting started with nanoarrow in C/C++" href="cpp.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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary" tabindex="0">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </header>
+
+
+ <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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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 class="sidebar-primary-item">
+<nav class="bd-docs-nav bd-links"
+ aria-label="Section Navigation">
+ <p class="bd-links__title" role="heading" aria-level="1">Section Navigation</p>
+ <div class="bd-toc-item navbar-nav"><ul class="current nav bd-sidenav">
+<li class="toctree-l1"><a class="reference internal" href="cpp.html">C/C++</a></li>
+<li class="toctree-l1 current active"><a class="current reference internal" href="#">Python</a></li>
+<li class="toctree-l1"><a class="reference internal" href="r.html">R</a></li>
+</ul>
+</div>
+</nav></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="Breadcrumb">
+ <ul class="bd-breadcrumbs">
+
+ <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"><a href="index.html" class="nav-link">Getting Started</a></li>
+
+ <li class="breadcrumb-item active" aria-current="page">nanoarrow for Python</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article">
+
+ <!---
+ 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.
+--><!-- Render with jupyter nbconvert --to markdown README.ipynb --><section id="nanoarrow-for-python">
+<h1>nanoarrow for Python<a class="headerlink" href="#nanoarrow-for-python" title="Link to this heading">#</a></h1>
+<p>The nanoarrow Python package provides bindings to the nanoarrow C
+library. Like the nanoarrow C library, it provides tools to facilitate
+the use of the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow C
+Data</a> and
+<a class="reference external" href="https://arrow.apache.org/docs/format/CStreamInterface.html">Arrow C
+Stream</a>
+interfaces.</p>
+<section id="installation">
+<h2>Installation<a class="headerlink" href="#installation" title="Link to this heading">#</a></h2>
+<p>Python bindings for nanoarrow are not yet available on PyPI. You can
+install via URL (requires a C compiler):</p>
+<div class="highlight-bash notranslate"><div class="highlight"><pre><span></span>python<span class="w"> </span>-m<span class="w"> </span>pip<span class="w"> </span>install<span class="w"> </span><span class="s2">"git+https://github.com/apache/arrow-nanoarrow.git#egg=nanoarrow&subdirectory=python"</span>
+</pre></div>
+</div>
+<p>If you can import the namespace, you’re good to go!</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">nanoarrow</span> <span class="k">as</span> <span class="nn">na</span>
+</pre></div>
+</div>
+</section>
+<section id="low-level-c-library-bindings">
+<h2>Low-level C library bindings<a class="headerlink" href="#low-level-c-library-bindings" title="Link to this heading">#</a></h2>
+<p>The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> which represents a data type of an
+array, the <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> which represents the values of an array, and
+an <code class="docutils literal notranslate"><span class="pre">ArrowArrayStream</span></code>, which represents zero or more <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code>s
+with a common <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code>.</p>
+<section id="schemas">
+<h3>Schemas<a class="headerlink" href="#schemas" title="Link to this heading">#</a></h3>
+<p>Use <code class="docutils literal notranslate"><span class="pre">nanoarrow.c_schema()</span></code> to convert an object to an <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code>
+and wrap it as a Python object. This works for any object implementing
+the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow PyCapsule
+Interface</a>
+(e.g., <code class="docutils literal notranslate"><span class="pre">pyarrow.Schema</span></code>, <code class="docutils literal notranslate"><span class="pre">pyarrow.DataType</span></code>, and <code class="docutils literal notranslate"><span class="pre">pyarrow.Field</span></code>).</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pyarrow</span> <span class="k">as</span> <span class="nn">pa</span>
+<span class="n">schema</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">c_schema</span><span class="p">(</span><span class="n">pa</span><span class="o">.</span><span class="n">decimal128</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">))</span>
+<span class="n">schema</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">decimal128</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span><span class="o">></span>
+<span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'d:10,3'</span>
+<span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">''</span>
+<span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">2</span>
+<span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>You can extract the fields of a <code class="docutils literal notranslate"><span class="pre">CSchema</span></code> object one at a time or
+parse it into a view to extract deserialized parameters.</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">na</span><span class="o">.</span><span class="n">c_schema_view</span><span class="p">(</span><span class="n">schema</span><span class="p">)</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchemaView</span><span class="o">></span>
+<span class="o">-</span> <span class="nb">type</span><span class="p">:</span> <span class="s1">'decimal128'</span>
+<span class="o">-</span> <span class="n">storage_type</span><span class="p">:</span> <span class="s1">'decimal128'</span>
+<span class="o">-</span> <span class="n">decimal_bitwidth</span><span class="p">:</span> <span class="mi">128</span>
+<span class="o">-</span> <span class="n">decimal_precision</span><span class="p">:</span> <span class="mi">10</span>
+<span class="o">-</span> <span class="n">decimal_scale</span><span class="p">:</span> <span class="mi">3</span>
+</pre></div>
+</div>
+<p>Advanced users can allocate an empty <code class="docutils literal notranslate"><span class="pre">CSchema</span></code> and populate its
+contents by passing its <code class="docutils literal notranslate"><span class="pre">._addr()</span></code> to a schema-exporting function.</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">schema</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">allocate_c_schema</span><span class="p">()</span>
+<span class="n">pa</span><span class="o">.</span><span class="n">int32</span><span class="p">()</span><span class="o">.</span><span class="n">_export_to_c</span><span class="p">(</span><span class="n">schema</span><span class="o">.</span><span class="n">_addr</span><span class="p">())</span>
+<span class="n">schema</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">int32</span><span class="o">></span>
+<span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'i'</span>
+<span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">''</span>
+<span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">2</span>
+<span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>The <code class="docutils literal notranslate"><span class="pre">CSchema</span></code> object cleans up after itself: when the object is
+deleted, the underlying <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> is released.</p>
+</section>
+<section id="arrays">
+<h3>Arrays<a class="headerlink" href="#arrays" title="Link to this heading">#</a></h3>
+<p>You can use <code class="docutils literal notranslate"><span class="pre">nanoarrow.c_array()</span></code> to convert an array-like object to
+an <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code>, wrap it as a Python object, and attach a schema that
+can be used to interpret its contents. This works for any object
+implementing the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow PyCapsule
+Interface</a>
+(e.g., <code class="docutils literal notranslate"><span class="pre">pyarrow.Array</span></code>, <code class="docutils literal notranslate"><span class="pre">pyarrow.RecordBatch</span></code>).</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">array</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">c_array</span><span class="p">(</span><span class="n">pa</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="s2">"one"</span><span class="p">,</span> <span class="s2">"two"</span><span class="p">,</span> <span class="s2">" [...]
+<span class="n">array</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArray</span> <span class="n">string</span><span class="o">></span>
+<span class="o">-</span> <span class="n">length</span><span class="p">:</span> <span class="mi">4</span>
+<span class="o">-</span> <span class="n">offset</span><span class="p">:</span> <span class="mi">0</span>
+<span class="o">-</span> <span class="n">null_count</span><span class="p">:</span> <span class="mi">1</span>
+<span class="o">-</span> <span class="n">buffers</span><span class="p">:</span> <span class="p">(</span><span class="mi">2939032895680</span><span class="p">,</span> <span class="mi">2939032895616</span><span class="p">,</span> <span class="mi">2939032895744</span><span class="p">)</span>
+<span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>You can extract the fields of a <code class="docutils literal notranslate"><span class="pre">CArray</span></code> one at a time or parse it
+into a view to extract deserialized content:</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">na</span><span class="o">.</span><span class="n">c_array_view</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArrayView</span><span class="o">></span>
+<span class="o">-</span> <span class="n">storage_type</span><span class="p">:</span> <span class="s1">'string'</span>
+<span class="o">-</span> <span class="n">length</span><span class="p">:</span> <span class="mi">4</span>
+<span class="o">-</span> <span class="n">offset</span><span class="p">:</span> <span class="mi">0</span>
+<span class="o">-</span> <span class="n">null_count</span><span class="p">:</span> <span class="mi">1</span>
+<span class="o">-</span> <span class="n">buffers</span><span class="p">[</span><span class="mi">3</span><span class="p">]:</span>
+ <span class="o">-</span> <span class="o"><</span><span class="nb">bool</span> <span class="n">validity</span><span class="p">[</span><span class="mi">1</span> <span class="n">b</span><span class="p">]</span> <span class="mi">11100000</span><span class="o">></span>
+ <span class="o">-</span> <span class="o"><</span><span class="n">int32</span> <span class="n">data_offset</span><span class="p">[</span><span class="mi">20</span> <span class="n">b</span><span class="p">]</span> <span class="mi">0</span> <span class="mi">3</span> <span class="mi">6</span> <span class="mi">11</span> <span class="mi">11</span><span class="o">></span>
+ <span class="o">-</span> <span class="o"><</span><span class="n">string</span> <span class="n">data</span><span class="p">[</span><span class="mi">11</span> <span class="n">b</span><span class="p">]</span> <span class="sa">b</span><span class="s1">'onetwothree'</span><span class="o">></span>
+<span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>Like the <code class="docutils literal notranslate"><span class="pre">CSchema</span></code>, you can allocate an empty one and access its
+address with <code class="docutils literal notranslate"><span class="pre">_addr()</span></code> to pass to other array-exporting functions.</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">array</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">allocate_c_array</span><span class="p">()</span>
+<span class="n">pa</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span><span class="o">.</span><span class="n">_export_to_c</span><span class="p">(</span><span class="n">array</span><span class="o">.</span><span class="n">_addr</span><span class="p">(),</span> <span class="n">array</span><span class="o">.</spa [...]
+<span class="n">array</span><span class="o">.</span><span class="n">length</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">3</span>
+</pre></div>
+</div>
+</section>
+<section id="array-streams">
+<h3>Array streams<a class="headerlink" href="#array-streams" title="Link to this heading">#</a></h3>
+<p>You can use <code class="docutils literal notranslate"><span class="pre">nanoarrow.c_array_stream()</span></code> to wrap an object
+representing a sequence of <code class="docutils literal notranslate"><span class="pre">CArray</span></code>s with a common <code class="docutils literal notranslate"><span class="pre">CSchema</span></code> to an
+<code class="docutils literal notranslate"><span class="pre">ArrowArrayStream</span></code> and wrap it as a Python object. This works for any
+object implementing the <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow PyCapsule
+Interface</a>
+(e.g., <code class="docutils literal notranslate"><span class="pre">pyarrow.RecordBatchReader</span></code>).</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">pa_array_child</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="n">pa</span><span class="o">.</span><span class="n">int32</span><span class="p"> [...]
+<span class="n">pa_array</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">record_batch</span><span class="p">([</span><span class="n">pa_array_child</span><span class="p">],</span> <span class="n">names</span><span class="o">=</span><span class="p">[</span><span class="s2">"some_column"</span><span class="p">])</span>
+<span class="n">reader</span> <span class="o">=</span> <span class="n">pa</span><span class="o">.</span><span class="n">RecordBatchReader</span><span class="o">.</span><span class="n">from_batches</span><span class="p">(</span><span class="n">pa_array</span><span class="o">.</span><span class="n">schema</span><span class="p">,</span> <span class="p">[</span><span class="n">pa_array</span><span class="p">])</span>
+<span class="n">array_stream</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">c_array_stream</span><span class="p">(</span><span class="n">reader</span><span class="p">)</span>
+<span class="n">array_stream</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArrayStream</span><span class="o">></span>
+<span class="o">-</span> <span class="n">get_schema</span><span class="p">():</span> <span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">struct</span><span class="o">></span>
+ <span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'+s'</span>
+ <span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">''</span>
+ <span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">0</span>
+ <span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">1</span><span class="p">]:</span>
+ <span class="s1">'some_column'</span><span class="p">:</span> <span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">int32</span><span class="o">></span>
+ <span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'i'</span>
+ <span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">'some_column'</span>
+ <span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">2</span>
+ <span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>You can pull the next array from the stream using <code class="docutils literal notranslate"><span class="pre">.get_next()</span></code> or use
+it like an iterator. The <code class="docutils literal notranslate"><span class="pre">.get_next()</span></code> method will raise
+<code class="docutils literal notranslate"><span class="pre">StopIteration</span></code> when there are no more arrays in the stream.</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">array</span> <span class="ow">in</span> <span class="n">array_stream</span><span class="p">:</span>
+ <span class="nb">print</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArray</span> <span class="n">struct</span><span class="o">></span>
+<span class="o">-</span> <span class="n">length</span><span class="p">:</span> <span class="mi">3</span>
+<span class="o">-</span> <span class="n">offset</span><span class="p">:</span> <span class="mi">0</span>
+<span class="o">-</span> <span class="n">null_count</span><span class="p">:</span> <span class="mi">0</span>
+<span class="o">-</span> <span class="n">buffers</span><span class="p">:</span> <span class="p">(</span><span class="mi">0</span><span class="p">,)</span>
+<span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+<span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">1</span><span class="p">]:</span>
+ <span class="s1">'some_column'</span><span class="p">:</span> <span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArray</span> <span class="n">int32</span><span class="o">></span>
+ <span class="o">-</span> <span class="n">length</span><span class="p">:</span> <span class="mi">3</span>
+ <span class="o">-</span> <span class="n">offset</span><span class="p">:</span> <span class="mi">0</span>
+ <span class="o">-</span> <span class="n">null_count</span><span class="p">:</span> <span class="mi">0</span>
+ <span class="o">-</span> <span class="n">buffers</span><span class="p">:</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2939033026688</span><span class="p">)</span>
+ <span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+<p>You can also get the address of a freshly-allocated stream to pass to a
+suitable exporting function:</p>
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">array_stream</span> <span class="o">=</span> <span class="n">na</span><span class="o">.</span><span class="n">allocate_c_array_stream</span><span class="p">()</span>
+<span class="n">reader</span><span class="o">.</span><span class="n">_export_to_c</span><span class="p">(</span><span class="n">array_stream</span><span class="o">.</span><span class="n">_addr</span><span class="p">())</span>
+<span class="n">array_stream</span>
+</pre></div>
+</div>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CArrayStream</span><span class="o">></span>
+<span class="o">-</span> <span class="n">get_schema</span><span class="p">():</span> <span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">struct</span><span class="o">></span>
+ <span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'+s'</span>
+ <span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">''</span>
+ <span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">0</span>
+ <span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">1</span><span class="p">]:</span>
+ <span class="s1">'some_column'</span><span class="p">:</span> <span class="o"><</span><span class="n">nanoarrow</span><span class="o">.</span><span class="n">c_lib</span><span class="o">.</span><span class="n">CSchema</span> <span class="n">int32</span><span class="o">></span>
+ <span class="o">-</span> <span class="nb">format</span><span class="p">:</span> <span class="s1">'i'</span>
+ <span class="o">-</span> <span class="n">name</span><span class="p">:</span> <span class="s1">'some_column'</span>
+ <span class="o">-</span> <span class="n">flags</span><span class="p">:</span> <span class="mi">2</span>
+ <span class="o">-</span> <span class="n">metadata</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">dictionary</span><span class="p">:</span> <span class="n">NULL</span>
+ <span class="o">-</span> <span class="n">children</span><span class="p">[</span><span class="mi">0</span><span class="p">]:</span>
+</pre></div>
+</div>
+</section>
+</section>
+<section id="development">
+<h2>Development<a class="headerlink" href="#development" title="Link to this heading">#</a></h2>
+<p>Python bindings for nanoarrow are managed with
+<a class="reference external" href="https://setuptools.pypa.io/en/latest/index.html">setuptools</a>. This
+means you can build the project using:</p>
+<div class="highlight-shell notranslate"><div class="highlight"><pre><span></span>git<span class="w"> </span>clone<span class="w"> </span>https://github.com/apache/arrow-nanoarrow.git
+<span class="nb">cd</span><span class="w"> </span>arrow-nanoarrow/python
+pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> </span>.
+</pre></div>
+</div>
+<p>Tests use <a class="reference external" href="https://docs.pytest.org/">pytest</a>:</p>
+<div class="highlight-shell notranslate"><div class="highlight"><pre><span></span><span class="c1"># Install dependencies</span>
+pip<span class="w"> </span>install<span class="w"> </span>-e<span class="w"> </span>.<span class="o">[</span>test<span class="o">]</span>
+
+<span class="c1"># Run tests</span>
+pytest<span class="w"> </span>-vvx
+</pre></div>
+</div>
+</section>
+</section>
+
+
+ </article>
+
+
+
+
+
+ <footer class="prev-next-footer">
+
+<div class="prev-next-area">
+ <a class="left-prev"
+ href="cpp.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 in C/C++</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="r.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">nanoarrow</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div>
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+
+ <div class="sidebar-secondary-item">
+<div
+ id="pst-page-navigation-heading-2"
+ class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc" aria-labelledby="pst-page-navigation-heading-2">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#installation">Installation</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#low-level-c-library-bindings">Low-level C library bindings</a><ul class="visible nav section-nav flex-column">
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#schemas">Schemas</a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#arrays">Arrays</a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#array-streams">Array streams</a></li>
+</ul>
+</li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#development">Development</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/python.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/python.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=8d27b9dea8ad943066ae"></script>
+<script src="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/getting-started/r.html b/latest/getting-started/r.html
new file mode 100644
index 00000000..2d6d667e
--- /dev/null
+++ b/latest/getting-started/r.html
@@ -0,0 +1,778 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="../" >
+
+ <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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="../_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="../_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="../_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="../_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="../_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="../_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="../_static/doctools.js?v=888ff710"></script>
+ <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'getting-started/r';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </script>
+ <link rel="index" title="Index" href="../genindex.html" />
+ <link rel="search" title="Search" href="../search.html" />
+ <link rel="next" title="Roadmap" href="../roadmap.html" />
+ <link rel="prev" title="nanoarrow for Python" href="python.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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary" tabindex="0">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </header>
+
+
+ <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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item current active">
+ <a class="nav-link nav-internal" href="index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="../reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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 class="sidebar-primary-item">
+<nav class="bd-docs-nav bd-links"
+ aria-label="Section Navigation">
+ <p class="bd-links__title" role="heading" aria-level="1">Section Navigation</p>
+ <div class="bd-toc-item navbar-nav"><ul class="current nav bd-sidenav">
+<li class="toctree-l1"><a class="reference internal" href="cpp.html">C/C++</a></li>
+<li class="toctree-l1"><a class="reference internal" href="python.html">Python</a></li>
+<li class="toctree-l1 current active"><a class="current reference internal" href="#">R</a></li>
+</ul>
+</div>
+</nav></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="Breadcrumb">
+ <ul class="bd-breadcrumbs">
+
+ <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"><a href="index.html" class="nav-link">Getting Started</a></li>
+
+ <li class="breadcrumb-item active" aria-current="page">nanoarrow</li>
+ </ul>
+</nav>
+</div>
+
+ </div>
+
+
+</div>
+</div>
+
+
+
+
+<div id="searchbox"></div>
+ <article class="bd-article">
+
+ <!---
+ 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.
+--><!-- README.md is generated from README.Rmd. Please edit that file --><section id="nanoarrow">
+<h1>nanoarrow<a class="headerlink" href="#nanoarrow" title="Link to this heading">#</a></h1>
+<!-- badges: start --><!-- badges: end --><p>The goal of nanoarrow is to provide minimal useful bindings to the
+<a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow C
+Data</a> and
+<a class="reference external" href="https://arrow.apache.org/docs/format/CStreamInterface.html">Arrow C
+Stream</a>
+interfaces using the <a class="reference external" href="https://arrow.apache.org/nanoarrow">nanoarrow C
+library</a>.</p>
+<section id="installation">
+<h2>Installation<a class="headerlink" href="#installation" title="Link to this heading">#</a></h2>
+<p>You can install the released version of nanoarrow from
+<a class="reference external" href="https://cran.r-project.org/">CRAN</a> with:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="nf">install.packages</span><span class="p">(</span><span class="s">"nanoarrow"</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>You can install the development version of nanoarrow from
+<a class="reference external" href="https://github.com/">GitHub</a> with:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="c1"># install.packages("remotes")</span>
+<span class="n">remotes</span><span class="o">::</span><span class="nf">install_github</span><span class="p">(</span><span class="s">"apache/arrow-nanoarrow/r"</span><span class="p">)</span>
+</pre></div>
+</div>
+<p>If you can load the package, you’re good to go!</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="nf">library</span><span class="p">(</span><span class="n">nanoarrow</span><span class="p">)</span>
+</pre></div>
+</div>
+</section>
+<section id="example">
+<h2>Example<a class="headerlink" href="#example" title="Link to this heading">#</a></h2>
+<p>The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code> which represents a data type of an
+array, the <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code> which represents the values of an array, and
+an <code class="docutils literal notranslate"><span class="pre">ArrowArrayStream</span></code>, which represents zero or more <code class="docutils literal notranslate"><span class="pre">ArrowArray</span></code>s
+with a common <code class="docutils literal notranslate"><span class="pre">ArrowSchema</span></code>. All three can be wrapped by R objects
+using the nanoarrow R package.</p>
+<section id="schemas">
+<h3>Schemas<a class="headerlink" href="#schemas" title="Link to this heading">#</a></h3>
+<p>Use <code class="docutils literal notranslate"><span class="pre">infer_nanoarrow_schema()</span></code> to get the ArrowSchema object that
+corresponds to a given R vector type; use <code class="docutils literal notranslate"><span class="pre">as_nanoarrow_schema()</span></code> to
+convert an object from some other data type representation (e.g., an
+arrow R package <code class="docutils literal notranslate"><span class="pre">DataType</span></code> like <code class="docutils literal notranslate"><span class="pre">arrow::int32()</span></code>); or use
+<code class="docutils literal notranslate"><span class="pre">na_XXX()</span></code> functions to construct them.</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="nf">infer_nanoarrow_schema</span><span class="p">(</span><span class="m">1</span><span class="o">:</span><span class="m">5</span><span class="p">)</span>
+<span class="c1">#> <nanoarrow_schema int32></span>
+<span class="c1">#> $ format : chr "i"</span>
+<span class="c1">#> $ name : chr ""</span>
+<span class="c1">#> $ metadata : list()</span>
+<span class="c1">#> $ flags : int 2</span>
+<span class="c1">#> $ children : list()</span>
+<span class="c1">#> $ dictionary: NULL</span>
+<span class="nf">as_nanoarrow_schema</span><span class="p">(</span><span class="n">arrow</span><span class="o">::</span><span class="nf">schema</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">arrow</span><span class="o">::</span><span class="nf">float64</span><span class="p">()))</span>
+<span class="c1">#> <nanoarrow_schema struct></span>
+<span class="c1">#> $ format : chr "+s"</span>
+<span class="c1">#> $ name : chr ""</span>
+<span class="c1">#> $ metadata : list()</span>
+<span class="c1">#> $ flags : int 0</span>
+<span class="c1">#> $ children :List of 1</span>
+<span class="c1">#> ..$ col1:<nanoarrow_schema double></span>
+<span class="c1">#> .. ..$ format : chr "g"</span>
+<span class="c1">#> .. ..$ name : chr "col1"</span>
+<span class="c1">#> .. ..$ metadata : list()</span>
+<span class="c1">#> .. ..$ flags : int 2</span>
+<span class="c1">#> .. ..$ children : list()</span>
+<span class="c1">#> .. ..$ dictionary: NULL</span>
+<span class="c1">#> $ dictionary: NULL</span>
+<span class="nf">na_int64</span><span class="p">()</span>
+<span class="c1">#> <nanoarrow_schema int64></span>
+<span class="c1">#> $ format : chr "l"</span>
+<span class="c1">#> $ name : chr ""</span>
+<span class="c1">#> $ metadata : list()</span>
+<span class="c1">#> $ flags : int 2</span>
+<span class="c1">#> $ children : list()</span>
+<span class="c1">#> $ dictionary: NULL</span>
+</pre></div>
+</div>
+</section>
+<section id="arrays">
+<h3>Arrays<a class="headerlink" href="#arrays" title="Link to this heading">#</a></h3>
+<p>Use <code class="docutils literal notranslate"><span class="pre">as_nanoarrow_array()</span></code> to convert an object to an ArrowArray
+object:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="nf">as_nanoarrow_array</span><span class="p">(</span><span class="m">1</span><span class="o">:</span><span class="m">5</span><span class="p">)</span>
+<span class="c1">#> <nanoarrow_array int32[5]></span>
+<span class="c1">#> $ length : int 5</span>
+<span class="c1">#> $ null_count: int 0</span>
+<span class="c1">#> $ offset : int 0</span>
+<span class="c1">#> $ buffers :List of 2</span>
+<span class="c1">#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`</span>
+<span class="c1">#> $ dictionary: NULL</span>
+<span class="c1">#> $ children : list()</span>
+<span class="nf">as_nanoarrow_array</span><span class="p">(</span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">1.1</span><span class="p">,</span><span class="w"> </span><span class="m">2.2</span><span class="p">)))</span>
+<span class="c1">#> <nanoarrow_array struct[2]></span>
+<span class="c1">#> $ length : int 2</span>
+<span class="c1">#> $ null_count: int 0</span>
+<span class="c1">#> $ offset : int 0</span>
+<span class="c1">#> $ buffers :List of 1</span>
+<span class="c1">#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> $ children :List of 1</span>
+<span class="c1">#> ..$ col1:<nanoarrow_array double[2]></span>
+<span class="c1">#> .. ..$ length : int 2</span>
+<span class="c1">#> .. ..$ null_count: int 0</span>
+<span class="c1">#> .. ..$ offset : int 0</span>
+<span class="c1">#> .. ..$ buffers :List of 2</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`</span>
+<span class="c1">#> .. ..$ dictionary: NULL</span>
+<span class="c1">#> .. ..$ children : list()</span>
+<span class="c1">#> $ dictionary: NULL</span>
+</pre></div>
+</div>
+<p>You can use <code class="docutils literal notranslate"><span class="pre">as.vector()</span></code> or <code class="docutils literal notranslate"><span class="pre">as.data.frame()</span></code> to get the R
+representation of the object back:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="n">array</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="nf">as_nanoarrow_array</span><span class="p">(</span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">1.1</span><span class= [...]
+<span class="nf">as.data.frame</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
+<span class="c1">#> col1</span>
+<span class="c1">#> 1 1.1</span>
+<span class="c1">#> 2 2.2</span>
+</pre></div>
+</div>
+<p>Even though at the C level the ArrowArray is distinct from the
+ArrowSchema, at the R level we attach a schema wherever possible. You
+can access the attached schema using <code class="docutils literal notranslate"><span class="pre">infer_nanoarrow_schema()</span></code>:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="nf">infer_nanoarrow_schema</span><span class="p">(</span><span class="n">array</span><span class="p">)</span>
+<span class="c1">#> <nanoarrow_schema struct></span>
+<span class="c1">#> $ format : chr "+s"</span>
+<span class="c1">#> $ name : chr ""</span>
+<span class="c1">#> $ metadata : list()</span>
+<span class="c1">#> $ flags : int 0</span>
+<span class="c1">#> $ children :List of 1</span>
+<span class="c1">#> ..$ col1:<nanoarrow_schema double></span>
+<span class="c1">#> .. ..$ format : chr "g"</span>
+<span class="c1">#> .. ..$ name : chr "col1"</span>
+<span class="c1">#> .. ..$ metadata : list()</span>
+<span class="c1">#> .. ..$ flags : int 2</span>
+<span class="c1">#> .. ..$ children : list()</span>
+<span class="c1">#> .. ..$ dictionary: NULL</span>
+<span class="c1">#> $ dictionary: NULL</span>
+</pre></div>
+</div>
+</section>
+<section id="array-streams">
+<h3>Array Streams<a class="headerlink" href="#array-streams" title="Link to this heading">#</a></h3>
+<p>The easiest way to create an ArrowArrayStream is from a list of arrays
+or objects that can be converted to an array using
+<code class="docutils literal notranslate"><span class="pre">as_nanoarrow_array()</span></code>:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="n">stream</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="nf">basic_array_stream</span><span class="p">(</span>
+<span class="w"> </span><span class="nf">list</span><span class="p">(</span>
+<span class="w"> </span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">1.1</span><span class="p">,</span><span class="w"> </span><span class="m">2.2</span><span class="p">)),</span>
+<span class="w"> </span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">3.3</span><span class="p">,</span><span class="w"> </span><span class="m">4.4</span><span class="p">))</span>
+<span class="w"> </span><span class="p">)</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+<p>You can pull batches from the stream using the <code class="docutils literal notranslate"><span class="pre">$get_next()</span></code> method.
+The last batch will return <code class="docutils literal notranslate"><span class="pre">NULL</span></code>.</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="n">stream</span><span class="o">$</span><span class="nf">get_next</span><span class="p">()</span>
+<span class="c1">#> <nanoarrow_array struct[2]></span>
+<span class="c1">#> $ length : int 2</span>
+<span class="c1">#> $ null_count: int 0</span>
+<span class="c1">#> $ offset : int 0</span>
+<span class="c1">#> $ buffers :List of 1</span>
+<span class="c1">#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> $ children :List of 1</span>
+<span class="c1">#> ..$ col1:<nanoarrow_array double[2]></span>
+<span class="c1">#> .. ..$ length : int 2</span>
+<span class="c1">#> .. ..$ null_count: int 0</span>
+<span class="c1">#> .. ..$ offset : int 0</span>
+<span class="c1">#> .. ..$ buffers :List of 2</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`</span>
+<span class="c1">#> .. ..$ dictionary: NULL</span>
+<span class="c1">#> .. ..$ children : list()</span>
+<span class="c1">#> $ dictionary: NULL</span>
+<span class="n">stream</span><span class="o">$</span><span class="nf">get_next</span><span class="p">()</span>
+<span class="c1">#> <nanoarrow_array struct[2]></span>
+<span class="c1">#> $ length : int 2</span>
+<span class="c1">#> $ null_count: int 0</span>
+<span class="c1">#> $ offset : int 0</span>
+<span class="c1">#> $ buffers :List of 1</span>
+<span class="c1">#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> $ children :List of 1</span>
+<span class="c1">#> ..$ col1:<nanoarrow_array double[2]></span>
+<span class="c1">#> .. ..$ length : int 2</span>
+<span class="c1">#> .. ..$ null_count: int 0</span>
+<span class="c1">#> .. ..$ offset : int 0</span>
+<span class="c1">#> .. ..$ buffers :List of 2</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``</span>
+<span class="c1">#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `3.3 4.4`</span>
+<span class="c1">#> .. ..$ dictionary: NULL</span>
+<span class="c1">#> .. ..$ children : list()</span>
+<span class="c1">#> $ dictionary: NULL</span>
+<span class="n">stream</span><span class="o">$</span><span class="nf">get_next</span><span class="p">()</span>
+<span class="c1">#> NULL</span>
+</pre></div>
+</div>
+<p>You can pull all the batches into a <code class="docutils literal notranslate"><span class="pre">data.frame()</span></code> by calling
+<code class="docutils literal notranslate"><span class="pre">as.data.frame()</span></code> or <code class="docutils literal notranslate"><span class="pre">as.vector()</span></code>:</p>
+<div class="highlight-r notranslate"><div class="highlight"><pre><span></span><span class="n">stream</span><span class="w"> </span><span class="o"><-</span><span class="w"> </span><span class="nf">basic_array_stream</span><span class="p">(</span>
+<span class="w"> </span><span class="nf">list</span><span class="p">(</span>
+<span class="w"> </span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">1.1</span><span class="p">,</span><span class="w"> </span><span class="m">2.2</span><span class="p">)),</span>
+<span class="w"> </span><span class="nf">data.frame</span><span class="p">(</span><span class="n">col1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nf">c</span><span class="p">(</span><span class="m">3.3</span><span class="p">,</span><span class="w"> </span><span class="m">4.4</span><span class="p">))</span>
+<span class="w"> </span><span class="p">)</span>
+<span class="p">)</span>
+
+<span class="nf">as.data.frame</span><span class="p">(</span><span class="n">stream</span><span class="p">)</span>
+<span class="c1">#> col1</span>
+<span class="c1">#> 1 1.1</span>
+<span class="c1">#> 2 2.2</span>
+<span class="c1">#> 3 3.3</span>
+<span class="c1">#> 4 4.4</span>
+</pre></div>
+</div>
+<p>After consuming a stream, you should call the release method as soon as
+you can. This lets the implementation of the stream release any
+resources (like open files) it may be holding in a more predictable way
+than waiting for the garbage collector to clean up the object.</p>
+</section>
+</section>
+<section id="integration-with-the-arrow-package">
+<h2>Integration with the arrow package<a class="headerlink" href="#integration-with-the-arrow-package" title="Link to this heading">#</a></h2>
+<p>The nanoarrow package implements <code class="docutils literal notranslate"><span class="pre">as_nanoarrow_schema()</span></code>,
+<code class="docutils literal notranslate"><span class="pre">as_nanoarrow_array()</span></code>, and <code class="docutils literal notranslate"><span class="pre">as_nanoarrow_array_stream()</span></code> for most
+arrow package types. Similarly, it implements
+<code class="docutils literal notranslate"><span class="pre">arrow::as_arrow_array()</span></code>, <code class="docutils literal notranslate"><span class="pre">arrow::as_record_batch()</span></code>,
+<code class="docutils literal notranslate"><span class="pre">arrow::as_arrow_table()</span></code>, <code class="docutils literal notranslate"><span class="pre">arrow::as_record_batch_reader()</span></code>,
+<code class="docutils literal notranslate"><span class="pre">arrow::infer_type()</span></code>, <code class="docutils literal notranslate"><span class="pre">arrow::as_data_type()</span></code>, and
+<code class="docutils literal notranslate"><span class="pre">arrow::as_schema()</span></code> for nanoarrow objects such that you can pass
+equivalent nanoarrow objects into many arrow functions and vice versa.</p>
+</section>
+</section>
+
+
+ </article>
+
+
+
+
+
+ <footer class="prev-next-footer">
+
+<div class="prev-next-area">
+ <a class="left-prev"
+ href="python.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 for Python</p>
+ </div>
+ </a>
+ <a class="right-next"
+ href="../roadmap.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">Roadmap</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div>
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+
+ <div class="sidebar-secondary-item">
+<div
+ id="pst-page-navigation-heading-2"
+ class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc" aria-labelledby="pst-page-navigation-heading-2">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#installation">Installation</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#example">Example</a><ul class="visible nav section-nav flex-column">
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#schemas">Schemas</a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#arrays">Arrays</a></li>
+<li class="toc-h3 nav-item toc-entry"><a class="reference internal nav-link" href="#array-streams">Array Streams</a></li>
+</ul>
+</li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#integration-with-the-arrow-package">Integration with the arrow package</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/r.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/r.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=8d27b9dea8ad943066ae"></script>
+<script src="../_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/index.html b/latest/index.html
index 9697045f..4f21bf88 100644
--- a/latest/index.html
+++ b/latest/index.html
@@ -1,2 +1,600 @@
+
<!DOCTYPE html>
-<meta http-equiv="refresh" content="0;URL=../0.4.0/index.html">
+
+
+<html lang="en" data-content_root="./" >
+
+ <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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="_static/doctools.js?v=888ff710"></script>
+ <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'index';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </script>
+ <link rel="index" title="Index" href="genindex.html" />
+ <link rel="search" title="Search" href="search.html" />
+ <link rel="next" title="Getting Started" href="getting-started/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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
+
+ <header 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="col-lg-3 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 class="navbar-item">
+<script>
+document.write(`
+ <div class="version-switcher__container dropdown">
+ <button id="pst-version-switcher-button-2"
+ type="button"
+ class="version-switcher__button btn btn-sm navbar-btn dropdown-toggle"
+ data-bs-toggle="dropdown"
+ aria-haspopup="listbox"
+ aria-controls="pst-version-switcher-list-2"
+ aria-label="Version switcher list"
+ >
+ Choose version <!-- this text may get changed later by javascript -->
+ <span class="caret"></span>
+ </button>
+ <div id="pst-version-switcher-list-2"
+ class="version-switcher__menu dropdown-menu list-group-flush py-0"
+ role="listbox" aria-labelledby="pst-version-switcher-button-2">
+ <!-- dropdown will be populated by javascript on page load -->
+ </div>
+ </div>
+`);
+</script></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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started/index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="reference/index.html">
+ API Reference
+ </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 navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></i></span>
+ </button>
+`);
+</script></div>
+
+ </div>
+
+ </div>
+
+
+ <div class="navbar-persistent--mobile">
+
+ <script>
+ document.write(`
+ <button class="btn navbar-btn search-button-field search-button__button" title="Search" aria-label="Search" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <i class="fa-solid fa-magnifying-glass"></i>
+ <span class="search-button__default-text">Search</span>
+ <span class="search-button__kbd-shortcut"><kbd class="kbd-shortcut__modifier">Ctrl</kbd>+<kbd class="kbd-shortcut__modifier">K</kbd></span>
+ </button>
+ `);
+ </script>
+ </div>
+
+
+
+ <label class="sidebar-toggle secondary-toggle" for="__secondary" tabindex="0">
+ <span class="fa-solid fa-outdent"></span>
+ </label>
+
+</div>
+
+ </header>
+
+
+ <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">
+ <ul class="bd-navbar-elements navbar-nav">
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="getting-started/index.html">
+ Getting Started
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="roadmap.html">
+ Roadmap
+ </a>
+ </li>
+
+
+ <li class="nav-item">
+ <a class="nav-link nav-internal" href="reference/index.html">
+ API Reference
+ </a>
+ </li>
+
+ </ul>
+</nav></div>
+
+ </div>
+
+
+
+ <div class="sidebar-header-items__end">
+
+ <div class="navbar-item">
+
+<script>
+document.write(`
+ <button class="btn btn-sm navbar-btn theme-switch-button" title="light/dark" aria-label="light/dark" data-bs-placement="bottom" data-bs-toggle="tooltip">
+ <span class="theme-switch nav-link" data-mode="light"><i class="fa-solid fa-sun fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="dark"><i class="fa-solid fa-moon fa-lg"></i></span>
+ <span class="theme-switch nav-link" data-mode="auto"><i class="fa-solid fa-circle-half-stroke fa-lg"></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">
+
+ <!---
+ 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="nanoarrow">
+<h1>nanoarrow<a class="headerlink" href="#nanoarrow" title="Link to this heading">#</a></h1>
+<p><a class="reference external" href="https://app.codecov.io/gh/apache/arrow-nanoarrow?branch=main"><img alt="Codecov test coverage" src="https://codecov.io/gh/apache/arrow-nanoarrow/branch/main/graph/badge.svg" /></a> <a class="reference external" href="https://arrow.apache.org/nanoarrow/main"><img alt="Documentation" src="https://img.shields.io/badge/Documentation-main-yellow" /></a> <a class="reference external" href="https://github.com/apache/arrow-nanoarrow"><img alt="nanoarrow on [...]
+<p>The nanoarrow library is a set of helper functions to interpret and
+generate <a class="reference external" href="https://arrow.apache.org/docs/format/CDataInterface.html">Arrow C Data
+Interface</a>
+and <a class="reference external" href="https://arrow.apache.org/docs/format/CStreamInterface.html">Arrow C Stream
+Interface</a>
+structures. The library is in active early development and users should
+update regularly from the main branch of this repository.</p>
+<p>Whereas the current suite of Arrow implementations provide the basis for
+a comprehensive data analysis toolkit, this library is intended to
+support clients that wish to produce or interpret Arrow C Data and/or
+Arrow C Stream structures where linking to a higher level Arrow binding
+is difficult or impossible.</p>
+<section id="using-the-c-library">
+<h2>Using the C library<a class="headerlink" href="#using-the-c-library" title="Link to this heading">#</a></h2>
+<p>The nanoarrow C library is intended to be copied and vendored. This can
+be done using CMake or by using the bundled nanoarrow.h/nanorrow.c
+distribution available in the dist/ directory in this repository.
+Examples of both can be found in the examples/ directory in this
+repository.</p>
+<p>A simple producer example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow.h"</span>
+
+<span class="kt">int</span><span class="w"> </span><span class="nf">make_simple_array</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="w"> </span><span class="n">array_out</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">schema_ou [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="n">array_out</span><span class="o">-></span><span class="n">release</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span>
+<span class="w"> </span><span class="n">schema_out</span><span class="o">-></span><span class="n">release</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</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">array_out</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_INT32</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">array_out</span><span class="p">));</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayAppendInt</span><span class="p">(</span><span class="n">array_out</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">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayAppendInt</span><span class="p">(</span><span class="n">array_out</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">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayAppendInt</span><span class="p">(</span><span class="n">array_out</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_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayFinishBuildingDefault</span><span class="p">(</span><span class="n">array_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="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowSchemaInitFromType</span><span class="p">(</span><span class="n">schema_out</span><span class="p">,</span><span class="w"> </span><span class="n">NANOARROW_TYPE_INT32</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>A simple consumer example:</p>
+<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf"><stdio.h></span>
+
+<span class="cp">#include</span><span class="w"> </span><span class="cpf">"nanoarrow.h"</span>
+
+<span class="kt">int</span><span class="w"> </span><span class="nf">print_simple_array</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="w"> </span><span class="n">array</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">schema</span [...]
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowError</span><span class="w"> </span><span class="n">error</span><span class="p">;</span>
+<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">ArrowArrayView</span><span class="w"> </span><span class="n">array_view</span><span class="p">;</span>
+<span class="w"> </span><span class="n">NANOARROW_RETURN_NOT_OK</span><span class="p">(</span><span class="n">ArrowArrayViewInitFromSchema</span><span class="p">(</span><span class="o">&</span><span class="n">array_view</span><span class="p">,</span><span class="w"> </span><span class="n">schema</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">array_view</span><span class="p">.</span><span class="n">storage_type</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">NANOARROW_TYPE_INT32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
+<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">"Array has storage that is not int32</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="kt">int</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">ArrowArrayViewSetArray</span><span class="p">(</span><span class="o">&</span><span class="n">array_view</span><span class="p">,</span><span class="w"> </span><span class="n">array</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">error</span><span [...]
+<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">result</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">ArrowArrayViewReset</span><span class="p">(</span><span class="o">&</span><span class="n">array_view</span><span class="p">);</span>
+<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">result</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">array</span><span class="o">-></span><span class="n [...]
+<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">"%d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">ArrowArrayViewGetIntUnsafe</span><span class="p">(</span><span class="o">&</span><span class="n">array_view</span><span class="p">,</span><span class="w"> </span><span class="n">i</sp [...]
+<span class="w"> </span><span class="p">}</span>
+
+<span class="w"> </span><span class="n">ArrowArrayViewReset</span><span class="p">(</span><span class="o">&</span><span class="n">array_view</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>
+</section>
+<section id="contents">
+<h2>Contents<a class="headerlink" href="#contents" title="Link to this heading">#</a></h2>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="getting-started/index.html">Getting Started</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="getting-started/cpp.html">C/C++</a></li>
+<li class="toctree-l2"><a class="reference internal" href="getting-started/python.html">Python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="getting-started/r.html">R</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="roadmap.html">Roadmap</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="roadmap.html#c-library">C library</a></li>
+<li class="toctree-l2"><a class="reference internal" href="roadmap.html#ipc-extension">IPC extension</a></li>
+<li class="toctree-l2"><a class="reference internal" href="roadmap.html#device-extension">Device extension</a></li>
+<li class="toctree-l2"><a class="reference internal" href="roadmap.html#r-bindings">R bindings</a></li>
+<li class="toctree-l2"><a class="reference internal" href="roadmap.html#python-bindings">Python bindings</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="reference/index.html">API Reference</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="reference/r.html">R API Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/python.html">Python API Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/c.html">C API Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/cpp.html">C++ API Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/testing.html">Testing API Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/ipc.html">IPC Extension Reference</a></li>
+<li class="toctree-l2"><a class="reference internal" href="reference/device.html">Device Extension Reference</a></li>
+</ul>
+</li>
+</ul>
+</div>
+</section>
+</section>
+
+
+ </article>
+
+
+
+
+
+ <footer class="prev-next-footer">
+
+<div class="prev-next-area">
+ <a class="right-next"
+ href="getting-started/index.html"
+ title="next page">
+ <div class="prev-next-info">
+ <p class="prev-next-subtitle">next</p>
+ <p class="prev-next-title">Getting Started</p>
+ </div>
+ <i class="fa-solid fa-angle-right"></i>
+ </a>
+</div>
+ </footer>
+
+ </div>
+
+
+
+ <div class="bd-sidebar-secondary bd-toc"><div class="sidebar-secondary-items sidebar-secondary__inner">
+
+
+ <div class="sidebar-secondary-item">
+<div
+ id="pst-page-navigation-heading-2"
+ class="page-toc tocsection onthispage">
+ <i class="fa-solid fa-list"></i> On this page
+ </div>
+ <nav class="bd-toc-nav page-toc" aria-labelledby="pst-page-navigation-heading-2">
+ <ul class="visible nav section-nav flex-column">
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#using-the-c-library">Using the C library</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#contents">Contents</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/index.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/index.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=8d27b9dea8ad943066ae"></script>
+<script src="_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae"></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-2024 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.2.6.
+ <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.15.2.
+</p></div>
+
+ </div>
+
+</div>
+
+ </footer>
+ </body>
+</html>
\ No newline at end of file
diff --git a/latest/objects.inv b/latest/objects.inv
new file mode 100644
index 00000000..399e773b
Binary files /dev/null and b/latest/objects.inv differ
diff --git a/latest/py-modindex.html b/latest/py-modindex.html
new file mode 100644
index 00000000..23a485bc
--- /dev/null
+++ b/latest/py-modindex.html
@@ -0,0 +1,445 @@
+
+<!DOCTYPE html>
+
+
+<html lang="en" data-content_root="./" >
+
+ <head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>Python Module 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=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/bootstrap.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+<link href="_static/styles/pydata-sphinx-theme.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+
+
+ <link href="_static/vendor/fontawesome/6.5.1/css/all.min.css?digest=8d27b9dea8ad943066ae" rel="stylesheet" />
+ <link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-solid-900.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-brands-400.woff2" />
+<link rel="preload" as="font" type="font/woff2" crossorigin href="_static/vendor/fontawesome/6.5.1/webfonts/fa-regular-400.woff2" />
+
+ <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=a746c00c" />
+
+ <!-- Pre-loaded scripts that we'll load fully later -->
+ <link rel="preload" as="script" href="_static/scripts/bootstrap.js?digest=8d27b9dea8ad943066ae" />
+<link rel="preload" as="script" href="_static/scripts/pydata-sphinx-theme.js?digest=8d27b9dea8ad943066ae" />
+ <script src="_static/vendor/fontawesome/6.5.1/js/all.min.js?digest=8d27b9dea8ad943066ae"></script>
+
+ <script src="_static/documentation_options.js?v=5929fcd5"></script>
+ <script src="_static/doctools.js?v=888ff710"></script>
+ <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
+ <script>DOCUMENTATION_OPTIONS.pagename = 'py-modindex';</script>
+ <script>
+ DOCUMENTATION_OPTIONS.theme_version = '0.15.2';
+ DOCUMENTATION_OPTIONS.theme_switcher_json_url = 'https://arrow.apache.org/nanoarrow/switcher.json';
+ DOCUMENTATION_OPTIONS.theme_switcher_version_match = '0.4.0';
+ DOCUMENTATION_OPTIONS.show_version_warning_banner = false;
+ </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"/>
+
+ <script>
+ DOCUMENTATION_OPTIONS.COLLAPSE_INDEX = true;
+ </script>
+
+
+ </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 id="pst-skip-link" class="skip-link" href="#main-content">Skip to main content</a>
+
+ <div id="pst-scroll-pixel-helper"></div>
+
+ <button type="button" class="btn rounded-pill" id="pst-back-to-top">
+ <i class="fa-solid fa-arrow-up"></i>
+ Back to top
+ </button>
+
+
+ <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>
... 26263 lines suppressed ...